泛型：类型擦除

首先，虚拟机是没有泛型类型的对象的，所有的对象都属于普通的类
无论何时定义一个泛型类型，都自动提供了一个相应的原始类型，原始类型的名字就是删去类型参数后的泛型类型的名字。擦除类型变量，替换为限定变量（若无限定的变量用Obejct，若有限定变量的话替换为第一个）

        List<String>  ls = new ArrayList<String>();
        List<Integer> li = new ArrayList<Integer>(); 
        System.out.println(ls.getClass() == li.getClass());

 输出结果为true，证明类型擦除成功。

List<Integer> list=new ArrayList<>();
        list.add(11);
        Method add = list.getClass().getDeclaredMethod("add", Object.class);
        add.invoke(list,"test");
        add.invoke(list,1.2);
        for(Object o:list){
            System.out.println(o);
        }

利用类型擦除的原理，用反射的手段就绕过了正常开发中编译器不允许的操作限制。

下面通过编译和反编译，查看是否真正的擦除

public class Plate<T> {
    private T item;
}

通过javac 编译 和javap -c -verbose反编译后

Signature: #12                          // <T:Ljava/lang/Object;>Ljava/lang/Object;
 

public class Plate<T extends Comparable> {
    private T item;
}

Signature: #12                          // <T::Ljava/lang/Comparable;>Ljava/lang/Object

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？下面是ArrayList的get方法源码：

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
E elementData(int index) {
     return (E) elementData[index];
    }

在return前，会根据泛型变量进行强转，所以不需要我们强制类型转换

方法也能够泛型擦除
在调用泛型方法时，可以指定泛型，也可以不指定泛型。在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到Object
在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类

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

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

        /**指定泛型的时候*/  
        int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}

约束和局限性：
1：不能用基本类型实例化类型参数
如ArrayList<double> 类型擦除后，Object类无法存储double类型的值

2：运行时类型查询只适用于原始类型
Plate a=new Plate();
    if(a instanceof Plate<String>){
         System.out.println(true);
    }

3：不能创建参数化类型的数组
  List<Integer>[] li2 = new ArrayList<Integer>[];
  List<Boolean> li3 = new ArrayList<Boolean>[];

这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。

List<Integer>和 List<Boolean>在 jvm 中等同于List<Object>，所有的类型信息都被擦除，程序也无法分辨一个数组中的元素类型具体是 
List<Integer>类型还是 List<Boolean>类型。

4：泛型在静态方法和静态类中的问题

public class Test2<T> {    
    public static T one;   //编译错误    
    public static  T show(T one){ //编译错误    
        return null;    
    }    
}

public class Test2<T> {    

    public static <T >T show(T one){ //正确    
        return null;    
    }    
}