java泛型机制详解篇二（深入理解泛型篇一）

如何理解Java中的泛型是伪泛型？泛型中类型擦除

Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。理解类型擦除对于用好泛型是很有帮助的，尤其是一些看起来“疑难杂症”的问题，弄明白了类型擦除也就迎刃而解了。

泛型的类型擦除原则是：

• 消除类型参数声明，即删除<>及其包围的部分。
• 根据类型参数的上下界推断并替换所有的类型参数为原生态类型：如果类型参数是无限制通配符或没有上下界限定则替换为Object，如果存在上下界限定则根据子类替换原则取类型参数的最左边限定类型（即父类）。
• 为了保证类型安全，必要时插入强制类型转换代码。
• 自动产生“桥接方法”以保证擦除类型后的代码仍然具有泛型的“多态性”。

泛型擦除

擦除类定义中的类型参数 - 无限制类型擦除
当类定义中的类型参数没有任何限制时，在类型擦除中直接被替换为Object，即形如和的类型参数都被替换为Object。如图所示：

擦除类定义中的类型参数 - 有限制类型擦除
当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如和的类型参数被替换为Number，被替换为Object。如图所示：

擦除方法定义中的类型参数
擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的，这里仅以擦除方法定义中的有限制类型参数为例。

如何证明类型的擦除呢？

原始类型相等

实例代码：

import java.util.ArrayList;

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

        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("abc");

        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(123);

        System.out.println(list1.getClass()); // class java.util.ArrayList
        System.out.println(list2.getClass()); // class java.util.ArrayList
        
        System.out.println(list1.getClass() == list2.getClass()); // true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

代码分析： 代码中定义了两个ArrayList数组，不过一个是ArrayList< String >泛型类型的，只能存储字符串；一个是ArrayList< Integer >泛型类型的，只能存储整数，最后，我们通过list1对象和list2对象的getClass()方法获取他们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下原始类型。

通过反射添加其它类型元素

实例代码：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<Integer>();

        list.add(1);  //这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer

        list.getClass().getMethod("add", Object.class).invoke(list, "asd");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果： 在程序中定义了一个ArrayList泛型类型实例化为Integer对象，如果直接调用add()方法，那么只能存储整数数据，不过当我们利用反射调用add()方法的时候，却可以存储字符串，这说明了Integer泛型实例在编译之后被擦除掉了，只保留了原始类型。

类型擦除后保留的原始类型

原始类型： 就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型，无论何时定义一个泛型，相应的原始类型都会被自动提供，类型变量擦除，并使用其限定类型（无限定的变量用Object）替换。
原始实例代码：

public class Animal<T> {
    T val;

    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }
}
1
2
3
4
5
6
7
8
9
10
11

当进行泛型擦除后，代码可以看作如下：

public class Animal {
    Object val;

    public Object getVal() {
        return val;
    }

    public void setVal(Object val) {
        this.val = val;
    }
}
1
2
3
4
5
6
7
8
9
10
11

分析： 因为在Animal < T >中，T 是一个无限定的类型变量，所以用Object替换，其结果就是一个普通的类，如同泛型加入Java语言之前的已经实现的样子。在程序中可以包含不同类型的Animal ，如Animal < String>或Animal < Integer >，但是擦除类型后他们的就成为原始的Animal 类型了，原始类型都是Object。

如果类型变量有限定，那么原始类型就用第一个边界的类型变量类替换。
比如： Pair这样声明的话，那么原始类型就是Comparable。

public class Pair<T extends Comparable> {}
1

在调用泛型方法时，可以指定泛型，也可以不指定泛型:：

• 在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到Object类
• 在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类

实例代码：

 public class Animal{
    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){
        return y;
    }
    public static void main(String[] args) {

        /**不指定泛型的时候*/
        int i = Animal.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
        Number f = Animal.add(1, 1.2); //这两个参数一个是Integer，一个是Float，所以取同一父类的最小级，为Number  
        Object o = Animal.add(1, "asd"); //这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object  

        /**指定泛型的时候*/
        int a = Animal.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Animal.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Animal.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型为Object，就比如ArrayList中，如果不指定泛型，那么这个ArrayList可以存储任意的对象。
Object类型的泛型实例：

public static void main(String[] args) {  
    ArrayList list = new ArrayList();  
    list.add(1);  
    list.add("121");  
    list.add(new Date());  
}  
1
2
3
4
5
6

泛型的编译期检查

类型变量会在编译的时候擦除掉，那为什么我们往 ArrayList 创建的对象中添加整数会报错呢？不是说泛型变量String会在编译的时候变为Object类型吗？为什么不能存别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？

首先，我们需要明确的是Java编译器是通过先检查代码中泛型的类型，然后在进行类型擦除，再进行编译，例如：

public static  void main(String[] args) {  

    ArrayList<String> list = new ArrayList<String>();  
    list.add("123");  
    list.add(123);//编译错误  
}
1
2
3
4
5
6

上面的程序中，使用add方法添加一个整型，在IDE中，直接会报错，说明这就是在编译之前的检查，因为如果是在编译之后检查，类型擦除后，原始类型为Object，是应该允许任意引用类型添加的。可实际上却不是这样的，这恰恰说明了关于泛型变量的使用，是会在编译之前检查的。

那么，这个类型检查是针对谁的呢？我们先看看参数化类型和原始类型的兼容。

以 ArrayList举例子，以前的写法：

ArrayList list = new ArrayList();  
1

现在的写法：

ArrayList<String> list = new ArrayList<String>();
1

如果是与以前的代码兼容，各种引用传值之间，必然会出现如下的情况：

ArrayList<String> list1 = new ArrayList(); //第一种 情况
ArrayList list2 = new ArrayList<String>(); //第二种 情况
1
2

这样是没有错误的，不过会有个编译时警告。
不过在第一种情况，可以实现与完全使用泛型参数一样的效果，第二种则没有效果。
因为类型检查就是编译时完成的，new ArrayList()只是在内存中开辟了一个存储空间，可以存储任何类型对象，而真正涉及类型检查的是它的引用，因为我们是使用它引用list1来调用它的方法，比如说调用add方法，所以 list1 引用能完成泛型类型的检查。而引用 list2 没有使用泛型，所以不行。例如：

public class Test {  

    public static void main(String[] args) {  

        ArrayList<String> list1 = new ArrayList();  
        list1.add("1"); //编译通过  
        list1.add(1); //编译错误  
        String str1 = list1.get(0); //返回类型就是String  

        ArrayList list2 = new ArrayList<String>();  
        list2.add("1"); //编译通过  
        list2.add(1); //编译通过  
        Object object = list2.get(0); //返回类型就是Object  

        new ArrayList<String>().add("11"); //编译通过  
        new ArrayList<String>().add(22); //编译错误  

        String str2 = new ArrayList<String>().get(0); //返回类型就是String  
    }  
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

通过上面的例子，我们可以明白，类型检查就是针对引用的，谁是一个引用，用这个引用调用泛型方法，就会对这个引用调用的方法进行类型检测，而无关它真正引用的对象。

泛型中参数话类型为什么不考虑继承关系？在Java中，像下面形式的引用传递是不允许的：

ArrayList<String> list1 = new ArrayList<Object>(); //编译错误  
ArrayList<Object> list2 = new ArrayList<String>(); //编译错误
1
2

我们先看第一种情况，将第一种情况拓展成下面的形式：

ArrayList<Object> list1 = new ArrayList<Object>();  
list1.add(new Object());  
list1.add(new Object());  
ArrayList<String> list2 = list1; //编译错误
1
2
3
4

实际上，在第4行代码的时候，就会有编译错误。那么，我们先假设它编译没错。那么当我们使用list2引用用get()方法取值的时候，返回的都是String类型的对象，可是它里面实际上已经被我们存放了Object类型的对象，这样就会有ClassCastException了。所以为了避免这种极易出现的错误，Java不允许进行这样的引用传递。

再看第二种情况，将第二种情况拓展成下面的形式：

ArrayList<String> list1 = new ArrayList<String>();  
list1.add(new String());  
list1.add(new String());

ArrayList<Object> list2 = list1; //编译错误
1
2
3
4
5

没错，这样的情况比第一种情况好的多，最起码，在我们用list2取值的时候不会出现ClassCastException，因为是从String转换为Object。可是，这样做有什么意义呢，泛型出现的原因，就是为了解决类型转换的问题。 我们使用了泛型，到头来，还是要自己强转，违背了泛型设计的初衷。所以java不允许这么干。再说，你如果又用list2往里面add()新的对象，那么到时候取得时候，我怎么知道我取出来的到底是String类型的，还是Object类型的呢？ 所以，要格外注意，泛型中的引用传递的问题

文章参考

• java全栈知识体系
• http://softlab.sdut.edu.cn/blog/subaochen/2017/01/generics-type-erasure/
• https://blog.csdn.net/sunxianghuang/article/details/51982979
• https://blog.csdn.net/LonelyRoamer/article/details/7868820
• https://docs.oracle.com/javase/tutorial/extra/generics/index.html
• https://blog.csdn.net/s10461/article/details/53941091
• https://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html
• https://www.cnblogs.com/rudy-laura/articles/3391013.html
• https://www.jianshu.com/p/986f732ed2f1
• https://blog.csdn.net/u011240877/article/details/53545041
• https://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html