深入剖析Java泛型

首先，我们要从概念上认识泛型，泛型的作用是什么？泛型是为了能够在编译时而不是在运行时检测出错误而产生的，以提高程序的可靠性、健壮性和鲁棒性。

有部分读者可能会有这样的理解误区：
如定义泛型ArrayList<String>list，比定义原始类型ArrayList list，能提高程序运行的效率，能减少JVM底层识别数据类型的时间。
注意！不管实际的具体类型是什么，泛型类是被它的所有实例所共享的，在JVM中只有原始类型被存储为单独一个类

如下面的例子所示

ArrayList<String> list1 = new ArrayList<String>();
ArrayList<Integer> list2 = new ArrayList<Integer>();
System.out.println(list1 instanceof ArrayList);  //true
System.out.println(list2 instanceof ArrayList);  //true
System.out.println(list1 instanceof ArrayList<String>);  //false

由此可知，泛型存在于编译时，一旦编译器确认泛型类型是安全使用的，就会将它转换为原始类型，JVM中只含有原始类型，所以上面的理解是错误的，泛型对运行时是毫无意义的，更谈不上提高效率。

正由于泛型的这个特点，所以不能用泛型类型参数创建实例：
E object = new E(); // false

此外，不能用泛型类型参数创建数组：
E[] elements = new E [capacity]; //false

同时不建议使用强制类型转换：
E[] elements = (E[])new Object [capacity];
如果 E 是 String，而 new Object[] 是 Integer 对象的数组，那么 (String[]) (new Object[]) 将会导致 ClassCastException 异常。

在静态环境下、异常类也是不能使用泛型的。

下面我们来观察一个例子：

import java.util.ArrayList;
import java.util.List;

class A {
}

class B extends A {
}

class D extends B {
}

public class TestGenericType {
    public static void main(String[] args) {

        List list = new ArrayList();
        List<A> listA = new ArrayList<A>();
        list = listA;// A正确

        List<B> listB = new ArrayList<B>();
        // listA=listB;//B错误

        List<Object> listObject = new ArrayList<Object>();
        List<?> list$ = new ArrayList<>();
        list$ = listObject;// C正确

        List<D> listD = new ArrayList<D>();
        List<? extends B> listExtendsB = new ArrayList<>();
        listExtendsB = listD;// D正确

        List<? extends A> listExtendsA = new ArrayList<>();
        // listA = listExtendsA;//E错误

        listExtendsA = listExtendsB;// F正确

        List<? super B> listSuperB = new ArrayList<>();
        listSuperB = listB;// G正确

        // listSuperB = listExtendsB;//H错误
    }

}

其中， ? 、 ? extends T 、 ? super T 是通配泛型。
? --->非受限通配，它和 ? extends Object 一样
? extends T --->受限通配，表示 T 或 T 的一个未知子类型
? super T --->下限通配，表示 T 或 T 的一个未知父类型

它们的关系如下图（摘自《Java语言程序设计》进阶篇）

Paste_Image.png

我们来做下分析：
【A】由第一张图的例子可知，listA instanceof list
【B】尽管 B 是 A 的子类，但 List<B> 不是 List<A> 的子类，所以 listA = listB 是错误的
【C】? 同等于 ? extends Object，list$ 能接收 Object 或 Object 的一个未知子类型，所以能接收 listObject
【D】解释同“C”
【E】同“A”，若 listExtendsA 接收的是 B 类，则 List<B> 不是 List<A> 的子类
【F】listExtendsA 能接收 A 或 A 的子类，正确
【G】listSuperB 能接收 B 或 B 的父类，正确
【H】listSuperB 不能接收 B 的子类，listExtendsB 可能接收 D类