什么是类型擦除？
类型擦除指的是通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。
类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。
类型擦除的主要过程如下：
1.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
2.移除所有的类型参数。
如：
interface Comparable <A> { public int compareTo( A that); } // 经过类型擦除后的类型为 interface Comparable { public int compareTo( Object that); }
1 final class NumericValue implements Comparable <NumericValue> { 2 priva te byte value; 3 public NumericValue (byte value) { this.value = value; } 4 public byte getValue() { return value; } 5 public int compareTo( NumericValue t hat) { return this.value - that.value; } 6 } 7 8 //经过类型擦除后的类型为 9 final class NumericValue implements Comparable { 10 priva te byte value; 11 public NumericValue (byte value) { this.value = value; } 12 public byte getValue() { return value; } 13 public int compareTo( NumericValue t hat) { return this.value - that.value; } 14 public int compareTo(Object that) { return this.compareTo((NumericValue)that); } 15 }
1 class Collections { 2 public static <A extends Comparable<A>>A max(Collection <A> xs) { 3 Iterator <A> xi = xs.iterator(); 4 A w = xi.next(); 5 while (xi.hasNext()) { 6 A x = xi.next(); 7 if (w.compareTo(x) < 0) w = x; 8 } 9 return w; 10 } 11 } 12 13 //经过类型擦除后的类型为 14 class Collections { 15 public static Comparable max(Collection xs) { 16 Iterator xi = xs.iterator(); 17 Comparable w = (Comparable) xi.next(); 18 while (xi.hasNext()) { 19 Comparable x = (Comparable) xi.next(); 20 if (w.compareTo(x) < 0) w = x; 21 } 22 return w; 23 } 24 }
1 final class Test { 2 public static void main (String[ ] args) { 3 LinkedList <NumericValue> numberList = new LinkedList <NumericValue> (); 4 numberList .add(new NumericValue((byte)0)); 5 numberList .add(new NumericValue((byte)1)); 6 NumericValue y = Collections.max( numberList ); 7 } 8 } 9 10 //经过类型擦除后的类型为 11 final class Test { 12 public static void main (String[ ] args) { 13 LinkedList numberList = new LinkedList(); 14 numberList .add(new NumericValue((byte)0)); ， 15 numberList .add(new NumericValue((byte)1)); 16 NumericValue y = (NumericValue) Collections.max( numberList ); 17 } 18 }
第一个泛型类Comparable <A>擦除后 A被替换为最左边界Object。Comparable<NumericValue>的类型参数NumericValue被擦除掉，但是这直 接导致NumericValue没有实现接口Comparable的compareTo(Object that)方法，于是编译器充当好人，添加了一个桥接方法。
第二个示例中限定了类型参数的边界<A extends Comparable<A>>A，A必须为Comparable<A>的子类，按照类型擦除的过程，先讲所有的类型参数 ti换为最左边界Comparable<A>，然后去掉参数类型A，得到最终的擦除后结果。
四、类型擦除带来的问题：是由于类型擦除的隐蔽存在，直接导致了众多的泛型灵异问题。
Q1.用同一泛型类的实例区分方法签名？——NO！
1 import java.util.*; 2 public class Erasure{ 3 public void test(List<String> ls){ 4 System.out.println("Sting"); 5 } 6 public void test(List<Integer> li){ 7 System.out.println("Integer"); 8 } 9 }
参数类型明明不一样啊，一个List<String>，一个是List<Integer>，但是，偷偷的说，type erasure之后，它就都是List了
Q2. 同时catch同一个泛型异常类的多个实例？——NO！
同理，如果定义了一个泛型一场类GenericException<T>，千万别同时catch GenericException<Integer> 和GenericException<String>，因为他们是一样一样滴
Q3.泛型类的静态变量是共享的？——Yes！
猜猜这段代码的输出是什么？
1 import java.util.*; 2 public class StaticTest{ 3 public static void main(String[] args){ 4 GT<Integer> gti = new GT<Integer>(); 5 gti.var=1; 6 GT<String> gts = new GT<String>(); 7 gts.var=2; 8 System.out.println(gti.var); 9 } 10 } 11 class GT<T>{ 12 public static int var=0; 13 public void nothing(T x){} 14 }
答案是——2！由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。
五、Just remember
1.虚拟机中没有泛型，只有普通类和普通方法
2.所有泛型类的类型参数在编译时都会被擦除
3.创建泛型对象时请指明类型，让编译器尽早的做参数检查（Effective Java，第23条：请不要在新代码中使用原生态类型）
4.不要忽略编译器的警告信息，那意味着潜在的ClassCastException等着你。
