类型擦除

第一篇 （转载至网络）

一、概述

      Java泛型在使用过程有诸多的问题，如不存在List.class, List不能赋值给List（不可协变），奇怪的ClassCastException等。 正确的使用Java泛型需要深入的了解Java的一些概念，如协变，桥接方法，以及这篇笔记记录的类型擦除。Java泛型的处理几乎都在编译器中进行，编 译器生成的bytecode是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。

二、编译器如何处理泛型？

     通常情况下，一个编译器处理泛型有两种方式：
     1.Code specialization。在实例化一个泛型类或泛型方法时都产生一份新的目标代码（字节码or二进制代码）。例如，针对一个泛型list，可能需要 针对string，integer，float产生三份目标代码。
     2.Code sharing。对每个泛型类只生成唯一的一份目标代码；该泛型类的所有实例都映射到这份目标代码上，在需要的时候执行类型检查和类型转换。
     C++中的模板（template）是典型的Code specialization实现。C++编译器会为每一个泛型类实例生成一份执行代码。执行代码中integer list和string list是两种不同的类型。这样会导致代码膨胀（code bloat），不过有经验的C＋＋程序员可以有技巧的避免代码膨胀。
     Code specialization另外一个弊端是在引用类型系统中，浪费空间，因为引用类型集合中元素本质上都是一个指针。没必要为每个类型都产生一份执行代码。而这也是Java编译器中采用Code sharing方式处理泛型的主要原因。
     Java编译器通过Code sharing方式为每个泛型类型创建唯一的字节码表示，并且将该泛型类型的实例都映射到这个唯一的字节码表示上。将多种泛型类形实例映射到唯一的字节码表示是通过类型擦除（type erasue）实现的。

三、 什么是类型擦除？

     类型擦除指的是通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。
     类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
     类型擦除的主要过程如下：
     1.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
     2.移除所有的类型参数。
     如
     

[java]  view plain copy print ?

1. interface Comparable  {   
2.   public int compareTo( A that);   
3. }   
4. final class NumericValue implements Comparable  {   
5.   priva te byte value;    
6.   public  NumericValue (byte value) { this.value = value; }    
7.   public  byte getValue() { return value; }    
8.   public  int compareTo( NumericValue t hat) { return this.value - that.value; }   
9. }   
10. －－－－－－－－－－－－－－－－－  
11. class Collections {    
12.   public static extends Comparable>A max(Collection  xs) {   
13.     Iterator  xi = xs.iterator();   
14.     A w = xi.next();   
15.     while (xi.hasNext()) {   
16.       A x = xi.next();   
17.       if (w.compareTo(x) < 0) w = x;   
18.     }   
19.     return w;   
20.   }   
21. }   
22. final class Test {   
23.   public static void main (String[ ] args) {   
24.     LinkedList  numberList = new LinkedList  ();   
25.     numberList .add(new NumericValue((byte)0));    
26.     numberList .add(new NumericValue((byte)1));    
27.     NumericValue y = Collections.max( numberList );    
28.   }   
29. }  

经过类型擦除后的类型为
 

[java]  view plain copy print ?

1. interface Comparable {   
2.   public int compareTo( Object that);   
3. }   
4. final class NumericValue implements Comparable {   
5.   priva te byte value;    
6.   public  NumericValue (byte value) { this.value = value; }    
7.   public  byte getValue() { return value; }    
8.   public  int compareTo( NumericValue t hat)   { return this.value - that.value; }   
9.   public  int compareTo(Object that) { return this.compareTo((NumericValue)that);  }   
10. }   
11. －－－－－－－－－－－－－  
12. class Collections {    
13.   public static Comparable max(Collection xs) {   
14.     Iterator xi = xs.iterator();   
15.     Comparable w = (Comparable) xi.next();   
16.     while (xi.hasNext()) {   
17.       Comparable x = (Comparable) xi.next();   
18.       if (w.compareTo(x) < 0) w = x;   
19.     }   
20.     return w;   
21.   }   
22. }   
23. final class Test {   
24.   public static void main (String[ ] args) {   
25.     LinkedList numberList = new LinkedList();   
26.     numberList .add(new NumericValue((byte)0));  ，  
27.     numberList .add(new NumericValue((byte)1));    
28.     NumericValue y = (NumericValue) Collections.max( numberList );    
29.   }   
30. }  

第一个泛型类Comparable  擦除后 A被替换为最左边界Object。Comparable的类型参数 NumericValue被擦除掉，但是这直 接导致NumericValue没有实现接口Comparable的compareTo(Object that)方法，于是编译器充当好人，添加了一个桥接方法。
第二个示例中限定了类型参数的边界 >A，A必须为Comparable 的子类，按照类型擦除的过程，先讲所有的类型参 数 ti换为最左边界Comparable ，然后去掉参数类型A，得到最终的擦除后结果。

四、类型擦除带来的问题

     正是由于类型擦除的隐蔽存在，直接导致了众多的泛型灵异问题。
 Q1.用同一泛型类的实例区分方法签名？——NO！
   

[java]  view plain copy print ?

1. import java.util.*;  
2.   
3.    public class Erasure{  
4.   
5.            public void test(List ls){  
6.                System.out.println("Sting");  
7.            }  
8.            public void test(List li){  
9.                System.out.println("Integer");  
10.            }  
11.    }  

编译该类，

参数类型明明不一样啊，一个List，一个是List，但是，偷偷的说，type erasure之后，它就都是List了⋯⋯
Q2. 同时catch同一个泛型异常类的多个实例？——NO！
同理，如果定义了一个泛型一场类GenericException，千万别同时catch GenericException和GenericException，因为他们是一样一样滴⋯⋯
Q3.泛型类的静态变量是共享的？——Yes！
猜猜这段代码的输出是什么？

[java]  view plain copy print ?

1. import java.util.*;  
2.   
3. public class StaticTest{  
4.     public static void main(String[] args){  
5.         GT gti = new GT();  
6.         gti.var=1;  
7.         GT gts = new GT();  
8.         gts.var=2;  
9.         System.out.println(gti.var);  
10.     }  
11. }  
12. class GT{  
13.     public static int var=0;  
14.     public void nothing(T x){}  
15. }  

答案是——2！由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。

五、Just remember

1.虚拟机中没有泛型，只有普通类和普通方法
2.所有泛型类的类型参数在编译时都会被擦除
3.创建泛型对象时请指明类型，让编译器尽早的做参数检查（Effective Java，第23条：请不要在新代码中使用原生态类型）
4.不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你。

第二篇 （转载至网络）


泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。泛型最主要的应用是在JDK 5中的新 集合类框架 中。对于泛型概念的引入，开发社区的观点是 褒贬不一 。 从好的方面来说，泛型的引入可以解决之前的集合类框架在使用过程中通常会出现的运行时刻类型错误，因为编译器可以在编译时刻就发现很多明显的错误。而从不 好的地方来说，为了保证与旧有版本的兼容性，Java泛型的实现上存在着一些不够优雅的地方。当然这也是任何有历史的编程语言所需要承担的历史包袱。后续 的版本更新会为早期的设计缺陷所累。   

开发人员在使用泛型的时候，很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List作为形式参数，那么如果 尝试将一个List的对象作为实际参数传进去，却发现无法通过编译。虽然从直觉上来说，Object是String的父类， 这种类型转换应该是合理的。但是实际上这会产生隐含的类型转换问题，因此编译器直接就禁止这样的行为。本文试图对Java泛型做一个概括性的说明。

类型擦除

正确理解泛型概念的首要前提是理解类型擦除（type erasure）。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译 器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List和List等类型，在 编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的 地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方式与C++模板机制实现方式之间的重要区别。

很多泛型的奇怪特性都与这个类型擦除的存在有关，包括：

• 泛型类并没有自己独有的Class类对象。比如并不存在List.class或是List.class，而只有List.class。
• 静态变量是被泛型类的所有实例所共享的。对于声明为MyClass的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass还是new MyClass创建的对象，都是共享一个静态变量。
• 泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是 无法区分两个异常类型MyException和MyException的。对于JVM来说， 它们都是 MyException类型的。也就无法执行与异常对应的catch语句。

类型擦除的基本过程也比较简单，首先是找到用来替换类型参数的具体类。这个具体类一般是Object。如果指定了类型参数的上界的话，则使用这个上 界。把代码中的类型参数都替换成具体的类。同时去掉出现的类型声明，即去掉<>的内容。比如T get()方法声明就变成了Object get()；List就变成了List。接下来就可能需要生成一些桥接方法（bridge method）。这是由于擦除了类型之后的类可能缺少某些必须的方法。比如考虑下面的代码：

class MyString implements Comparable { public int compareTo(String str) { return 0; } }

当类型信息被擦除之后，上述类的声明变成了class MyString implements Comparable。但是这样的话，类MyString就会有编译错误，因为没有实现接口Comparable声明的int compareTo(Object)方法。这个时候就由编译器来动态生成这个方法。

实例分析

了解了类型擦除机制之后，就会明白编译器承担了全部的类型检查工作。编译器禁止某些泛型的使用方式，正是为了确保类型的安全性。以上面提到的List和List为例来具体分析：

public void inspect(Listlist) { for (Object obj : list) { System.out.println(obj); } list.add(1); //这个操作在当前方法的上下文是合法的。 } public void test() { List strs = new ArrayList(); inspect(strs); //编译错误 }  

这段代码中，inspect方法接受List作为参数，当在test方法中试图传入 List的时候，会出现编译错误。假设这样的做法是允许的，那么在inspect方法就可以通过list.add(1)来向 集合中添加一个数字。这样在test方法看来，其声明为List的集合中却被添加了一个Integer类型的对象。这显然是 违反类型安全的原则的，在某个时候肯定会抛出ClassCastException。因此，编译器禁止这样的行为。编译器会尽可能的检查可能存在的类型安全问题。对于确定是违反相关原则的地方，会给出编译错误。当编译器无法判断类型的使用是否正确的时候，会给出警告信息。 

通配符与上下界

在使用泛型类的时候，既可以指定一个具体的类型，如List就声明了具体的类型是String；也可以用通配符?来表 示未知类型，如List