一 概述
Java泛型是JDK1.5中引入的新特性，本质是参数化类型，意思是允许在定义类、接口、方法时使用类型形参，当使用时指定具体类型，所有使用该泛型参数的地方都被统一化，保证类型一致。如果未指定具体类型，默认是Object类型。也就是所操作的数据类型被指定一个参数，这种参数可以在类，接口和方法的创建中，分别为泛型类，泛型接口，泛型方法。此外，集合体系中的所有类都增加了泛型，泛型也主要用在集合。
二 泛型的限制和规则
- 泛型的类型参数只能是引用类型，不能是值类型，也可以理解为只能是包装类型，不能是基本数据类型。
- 泛型的类型参数可以是多个。
- 泛型类不是真正存在的类，不能够通过instanceof运算符运算。
- 泛型类的类型参数不能在静态中声明。
- 如果定义了泛型，不指定具体的数据类型，泛型默认指定为Object类型。
- 泛型使用？作为类型通配符，表示未知类型，可以匹配任何类型，但由于是未知，所以无法添加元素。
- 类型通配符上限<? extends T>，？代表的是T的子类或者是T本身。常用于泛型方法，避免类型转换。
- 类型通配符下限<? super T>，？代表的是T的父类或者是T本身。
- 通配符可以实现限制类，接口和方法中定义的泛型参数的上限和下限。
三 泛型的定义
泛型类：public class Demo<T> { } T为未知类型。
泛型接口：public interface ImplDemo<T> { } 由于接口是一个特殊的类，所以同泛型类。
泛型方法：public <T> void method(T data) { int a; }
public <T> T method2(T t) { return t；}四 泛型的优点
- 泛型对于非静态的参数会在编译的时候确定类型，且保证类型安全，从而避免类型转换异常。
- 泛型可以避免类型之间的强制转换。
- 使用泛型可以提高代码的复用，从而使得代码更加具有通用性。
五 泛型代码实例
接下来，使用代码来演示泛型的用途，建议使用目录查看具体内容。
集合类演示泛型：
//未指定泛型
TreeSet ts = new TreeSet();
ts.add(10);
ts.add(25);
ts.add("30");
System.out.println(ts);//运行时报错，类型转换异常
//mode 2
TreeSet<Integer> ts2 = new TreeSet<>();
ts2.add(10);
ts2.add(25);
ts2.add("30"); //编译器提示报错，无法添加非Integer类型未使用泛型时，可以添加任意元素，因为TreeSet会比较每一个元素，所以运行时会引发类型转换异常。使用泛型后，只能添加同一个类型，所以不会出错。
定义泛型类
public class Person<T> {
private T name;//类型是未知的
public Person(T name) {
this.name = name;
}
public T getName() {
return name;
}
public void sexName(T name) {
this.name = name;
}
}在上面实例中，Person类定义成泛型类，成员变量name的类型指定为T，表示未知类型。实例化该类对象后，可以看到name的类型是Object，表示可以接收任何类型。
Person p = new Person(10); //new Person(Object name)加上泛型后
//使用泛型两种方式
Person<String> ps = new Person<String>(); //new Person<String>(String name)
Person<String> ps = new Person<>();//new Person<>(T name)第一种，会直接确定参数类型是什么，而第二种的参数类型是T ，但如果加入的非String类型，编译器会检查并报错。两者区别不大。在JDK1.7之后使用第二种，会自动检查泛型，可以省略后部分<>的泛型参数，建议JDK1.7版本或更高版本使用第二种。
定义泛型接口
interface A<T>{
void display(T value);
T getValue(T v);
}//未对泛型接口指定具体类型
public class Person implements A{
@Override
public void display(Object obj) {
System.out.println();
}
@Override
public Object getValue(Object v) {
return null;
}
}如果我们定义了泛型，不指定具体类型，默认就是Object类型。当我们为泛型接口指定具体类型后，代码如下：
//泛型接口
interface A<T>{
void display(T value);
T getValue(T v);
}
//为泛型接口指定具体类型
public class Person implements A<String>{
@Override
public void display(String value) {
}
@Override
public String getValue(String v) {
return null;
}
}泛型接口指定具体类型后，所有使用了该泛型参数的地方都被统一化。其实泛型接口和泛型类是一样的写法。
定义泛型方法
先使用常规方法进行对比。
public static void main(String[] args) {
int[] arr = new int[] {1, 8, 15, 6, 3};
double[] douArr = {10.5, 25.1, 4.9, 1.8};
String[] strArr = {"我","是","字","符","串"};
forArr(strArr);
}
//遍历数组的重载方法，支持int和double类型
public static void forArr(int[] arr) {
for(int i=0; i<arr.length; i++) {
System.out.println(arr[i]);
}
}
//重载了
public static void forArr(double[] arr) {
for(double d : arr) {
System.out.println(d);
}
}
如上所示，如果想遍历Stirng类型数组，那就还要再次重载代码，如果是八种类型都有，代码量非常庞大。使用泛型方法全部通用，代码如下：
public static void main(String[] args) {
Integer[] arr = {1, 8, 15, 6, 3};
Double[] douArr = {10.5, 25.1, 4.9, 1.8};
String[] strArr = {"我","是","字","符","串"};
forArrGenric(strArr);
}
//泛型方法
public static <T> void forArrGenric(T[] arr) {
for(int i=0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}只需定义一个泛型方法，根据运行时传入的参数类型，动态地获取类型，就能做到遍历所有类型数组。但需要注意，泛型的类型参数只能是引用类型，值类型无法在泛型中使用，所以上面的数组都改成了引用类型。值类型需要使用对应的包装类类型。
使用类型通配符
使用之前，先使用常规方式来进行比较。
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add("A");
hs.add("QQ");
hs.add("Alipay");
new Test2().test2(hs);
}
//普通遍历Set集合，Set是泛型接口，没指定具体泛型参数会引起警告
public void test(Set s) {
for(Object o : s)
System.out.println(o);
}
//增加泛型参数，参数类型是Set<Object>
public void test2(Set<Object> s) {
for(Object o : s)
System.out.println(o);
}方法参数的Set集合使用了泛型参数<Object>，方便将参数类型转换成Object，看起来没什么错。当传入一个带泛型参数的集合时，会出现编译错误。代码如下：
public static void main(String[] args) {
HashSet<String> hs = new HashSet();
hs.add("A");
hs.add("QQ");
hs.add("Alipay");
new Test2().test2(hs); //error
}
//增加泛型参数，参数类型是Set<Object>
public void test2(Set<Object> s) {
for(Object o : s)
System.out.println(o);
}因为泛型类不是真正存在的类，所以Set<String>和Set<Object>不存在关系，自然无法作为参数传入进去。这时我们就可以使用类型通配符，如下：
//使用类型通配符作为类型参数
public void test2(Set<?> s) {
for(Object o : s)
System.out.println(o);
}Set<?>表示可以匹配任意的泛型Set。虽然可以使用各种泛型Set了。但弊端就是类型未知，所以无法添加元素。还有范围过于广泛，所以这时可以考虑限制的类型通配符。
限制的类型通配符
上面代码只要是泛型Set都允许被遍历，如果只想类型通配符表示一个类和其子类本身呢？设置类型通配符上限，代码如下：
public class Test2 {
public static void main(String[] args) {
ArrayList<Test2> ar = new ArrayList<>();
List<Test3> lt = new ArrayList<>();
List<String> lStr = new ArrayList<>();
demo(ar);
demo(lt);
demo(lStr); //error
}
//限制的类型通配符
public static void demo(List<? extends Test2> t) {
for(int i = 0; i < t.size(); i++) {
System.out.println(t.get(i));
}
}
}
class Test3 extends Test2{}//子类<? extends T>：表示类型是T本身或者是T类型的子类类型，称作类型通配符的上限制。
<? super T>：表示类型是T类型本身或者是T类型的父类类型，称作类型通配符的下限。使用方式同上。
泛型为何不能应用于静态申明的实例解析
先给一个例子，在静态变量中和静态代码块中使用泛型。
public class Test<T> {
public static T name; //error
public T sex ;
static {
T ab; //error
}
}报出异常：不能使一个静态引用指向一个非静态的类型 T。静态和非静态之分就在于静态是编译时类型，动态是运行时类型。T代表未知类型，如果可以用于静态申明，因为是未知类型，系统没法指定初始值，手动赋值也不行，因为不知道啥类型，只有运行时才可以指定。而泛型存在的意义就是为了动态指定具体类型，增强灵活性和通用性，所以用于静态声明违背了使用原则。为什么实例变量和实例方法可以使用呢？因为当你使用实例变量或者方法时，就说明对象存在了，即代表泛型参数也指定了。未指定具体类型默认是Object类型。
为什么静态方法中可以定义泛型方法呢？
先给三个实例，我们来慢慢分析。
public class Test<T> {
public static void main(String[] args) {
}
//泛型方法
public T demo1(T t) {
return t;
}
//静态方法使用泛型参数
//public static T demo2(T t) { return t;}
//定义泛型静态方法
public static <T> void demo3(T t) {
System.out.println(w);
}
}首先，要明确一点，泛型作用是确定具体类型。先看一个泛型方法，使用了泛型参数T作为返回值，当使用对象时来调用该方法时，T类型会变成具体类型。第二个泛型方法是静态的，使用了T作为返回值和方法参数类型，但是静态方法是属于类的，类直接调用的话，T类型无法指定具体类型，那么该方法就没有意义。所以直接报错。第三个也是静态方法，但是该静态方法是自定义一个泛型参数，并非使用类型参数。所以当传入一个具体类型时，该静态方法的<T>就是具体类型了。两者静态方法的区别就是一个是静态方法使用泛型参数，一个是定义泛型静态方法。