什么是泛型
泛型，简单来讲就是在定义类、接口或方法的时候，将数据类型参数化，由使用这些类/接口/方法的一方传入所需要的数据类型，并有编译器进行类型安全检查和强制转换。例如我们常用的List<Integer>就是泛型的一种用法，我们通过<Integer>指定了这个List的类型只能时Integer。
泛型的好处
- 提高了代码的重用率，一段代码可以被不同数据类型的对象所重用
- 提供了编译阶段的类型安全检查，尤其是对集合类型而言。如下面代码中，list作为一个数据容器，可以存放任何类型，但若取出数据的时候没有做类型检查的话，就会报“java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer”数据类型转换异常的错，这种错误若完全靠程序员自己避免的话，是一件十分危险和低效的事情。
List list = new ArrayList();
list.add(1);
list.add("test");
list.add(1.1);
for (int i = 0; i < list.size(); i++) {
int item = (int)list.get(i);
System.out.println(item);
}
但若使用泛型就可以避免这种事情，不符合类型规定的数据就会被编译器发现并报错
List<Integer> list = new ArrayList();
list.add(1);
list.add("test"); // 在编译阶段就会报错
泛型的实现
简单概述一下，Java的泛型是编译器层面的技术，编译器在生成Java字节码时并不会记录泛型中的类型信息，只会保留原始类型(raw type)，而仅在Class的实例中包含了类型参数的定义信息，之后当调用泛型对象的时候会再进行数据类型的强制转换。编译器去除类型参数信息这个过程就称为类型擦除。
下面的代码可以证明在Runtime中不管是Integer还是String的信息都被擦除了，对编译器来讲两个list都是ArrayList。
List<Integer> listInteger = new ArrayList();
List<String> listString = new ArrayList<>();
System.out.println(listInteger.getClass().equals(listString.getClass()));//true
System.out.println(listInteger.getClass());//class java.util.ArrayList
System.out.println(listString.getClass());//class java.util.ArrayList
泛型的用法
在Java中，可以在类、接口或方法的定义后面用尖括号(<>)和类型参数表示泛型，形如<T>。其中类型参数起着占位符的作用，指示在运行时为类分配类型。根据实际需要，可以有一个或多个类型参数(如GenericContainer<T, E>)。
值得注意的是，在传入类型实参的时候，数据类型必须为包装类，不能为简单类型。
习惯上是单个大写字母表示类型参数，并有以下的标准类型参数：
- E：元素
- K：键
- N：数字
- T：类型
- V：值
- S、U、V 等：多参数情况中的第 2、3、4 个类型
1、泛型类
泛型类型用于类的定义中，被称为泛型类。最典型的就是各种容器类，如：List、Set、Map。通过代码直观地看一下。
这是一个泛型类GenericContainer。
public class GenericContainer<T> {
private T obj;
public GenericContainer(){
}
public GenericContainer(T t){
obj = t;
}
public T getObj() {
return obj;
}
public void setObj(T t) {
obj = t;
}
}
当声明一个泛型实例的时候，若传入类型参数，则编译器会对之后对数据做类型检查，并对不兼容的类型抛出错误。
GenericContainer<Integer> integerContainer = new GenericContainer<>(1);
GenericContainer<String> stringContainer = new GenericContainer<>("string");
System.out.println(integerContainer.getObj()); //1
System.out.println(stringContainer.getObj()); //string
// Error:(18, 33) java: 不兼容的类型: java.lang.String无法转换为java.lang.Integer
integerContainer.setObj("test");
当没有传入类型参数的时候，泛型类也是可以被初始化的，且此时编译器不会被传入的数据进行类型检查，这样也就失去类泛型的好处，在强制类型转换的时候会抛出ClassCastException异常
GenericContainer container = new GenericContainer();
container.setObj(1);
System.out.println(container.getObj()); //1
container.setObj("string");
System.out.println(stringContainer.getObj()); //string
//抛出java.lang.ClassCastException异常
Integer obj = (Integer) container.getObj();
2、泛型接口
泛型类型用于接口的定义中时，此接口成为泛型接口，它的定义和用法与泛型类基本相同。泛型的实现类必须申明泛型(即类命后的<T>不可丢)或者传入类型实参。代码如下：
public interface GenericInterface<T> {
public T get();
}
// 不做类型限制，由实例指定参数类型
public class GenericInImpl<T> implements GenericInterface<T> {
@Override
public String get() {
return null;
}
}
// 实现类已经限制了类型
public class GenericInImplTwo implements GenericInterface<String> {
@Override
public T get() {//此处的T应该替换成已经指定的String类型
return null;
}
}
3、泛型方法
形式如下的function称为泛型方法。可以是参数类型为T也可以是返回值为T。
“public”和函数的返回值之间的<T>不可丢，这是申明该方法是泛型方法的标志。这种方法多用于编写工具，比如Object2Json这种通用工具方法。
public <T> T returnT(T data){
T obj = (T)new Object();
return obj;
}
泛型方法容易和泛型类/泛型接口中的方法混淆。值得注意的是，泛型类/泛型接口中的方法并不是泛型方法，只是需要用到类定义中的类型参数的普通方法而已。泛型类/泛型接口中也可以定义泛型方法，此时该方法的类型参数是独立于类/接口的，也就是说调用该方法的时候可以传入与类/接口定义中相同的类型，也可以是不同的类型。以代码为例：
public class GenericContainer<T> {
private T obj;
public GenericContainer(T t){
obj = t;
}
public void printClass1(T t){
System.out.println(t.getClass());
}
public <T> void printClass2(T t){
System.out.println(t.getClass());
}
public <E> void printClass3(E e){
System.out.println(e.getClass());
}
}
从下面代码的执行结果中我们可以看到用<T>申明的泛型方法是不受泛型类的类型约束的，而是根据调用时传入的参数类型约束。
GenericContainer<String> container = new GenericContainer<>("string");
// Error:(27, 31) java: 不兼容的类型: int无法转换为java.lang.String
container.printClass1(1);
// class java.lang.Integer
container.printClass2(1);
// class java.lang.Double
container.printClass3(1.1);
4、泛型通配符
我们知道，对象或者数组是可以向上转型的，如下面代码是可以通过编译和运行的。
Number number = new Integer();
Number[] numbers = new Integer[10];
但泛型容器是不支持的,比如下面的代码就无法通过编译，尽管Integer是Number的子类，但ArrayList<Integer>并不是ArrayList<Number>的子类。
// Compile Error: incompatible types:
ArrayList<Number> numberList = new ArrayList<Integer>();
此时我们引入一个通配符的概念，符号标志为"?"，代表着某种类型,但不知道具体但类型。值得注意的是，用了?通配符后，该数组就不再被允许添加，只能查询删除等操作，因为此时我们不知道该数组的具体类型，往里面进行添加数据是一种非常不安全的操作。从通配符标志的数组中取出来的数据需要显式地做数据类型转换。通配符可以通过“extends”、“super”界定范围，其中利用“super”范围的数组可以添加数据。详见第5小节。
// 合法，但不允许add操作
ArrayList<?> numbers = new ArrayList<Integer>();
List<?> numberList = Arrays.asList(1);
Integer number = (Integer)numberList.get(0);
System.out.println(number);// 1
5、PECS
PECS即“Producer Extends,Consumer Super”的简称，“extends”和“super”都是用来进行泛型限定的修饰符。
“extends‘代表的是上限，“T extends Number”表示可以接收Number类型或者Number的子类型对象。也可以和通配符一起使用，"? extends Number"也代表可以接收Number类型或者Number的子类型对象。“Producer Extends”的含义是若参数化类型表示一个生产者，就使用<? extends T>。举个具体的例子
// 合法
ArrayList<? extends Number> numberList = new ArrayList<Integer>();
// 不合法，无法通过编译
ArrayList<? extends Number> numberList2 = new ArrayList<String>();
在以上代码中，numberList被限制为了可以接收Number类型或者Number的子类型对象的数组，如果给它赋予整数类型的数组是合法的，但赋予字符串类型的数组就无法通过编译，因为超出了界限。同时，还有一点非常重要，就是numberList只能作为数据的生产者，即提供数据给别人消费，但不能消费数据。从数组的角度来讲，就是可以获取numberList中的数据，但不能往里面添加，从而避免了下面这种不安全的情况
ArrayList<? extends Number> numberList = new ArrayList<Integer>();
numberList.add(1);
numberList.add(1.1);
Integer number = (Double)numberList.get(1);// 类型转换异常
“super‘代表的是下限，“T super Integer”：可以接收Integer类型或者Integer的父类型对象。同样super也可以和通配符一起使用。也就是说我们不知道这个T或者?符号代表着什么类，但这个类一定是Integer的父类。“Consumer Super”的含义是若参数化类型表示一个数据的消费者者，就使用<? super T>，在数组上的表现是你可以往里面add数据。
PECS之外，其实还有一个约定，就是如果一个数组即是生产者又是消费者，那么它一个用List<T>，而不是List<? extends T>或List<? super T>。
总结
- 泛型的类型参数只能是包装类(包括自定义类)，不能是简单类型；
- 同一种泛型可以对应多个版本(因为参数类型是不确定的)，不同版本的泛型类实例是不兼容的；
- 泛型的类型参数可以有多个；
- 泛型的参数类型可以使用extends、super语句，用于约束类型的界限
- 泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String")
- Producer Extends，Consumer Super
