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, "abc");

        for (Object obj : list) {
            System.out.println(obj);
        }
}

输出

1
abc

证明了java的泛型在运行期间是不存在，在编译期间会被删除

泛型擦除后替换的类型

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

未擦除泛型

class MyClass<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}

擦除并替换类型

class MyClass {
    private Object value;
    public Object getValue() {
        return value;
    }
    public void setValue(Object value) {
        this.value = value;
    }
}

因为MyClass<T>是一个无限定类型，所以用原始类型替换，原始类型都是Object

在反射添加其它类型的例子中List<Integer>，原始类型编程Object，所以可以通过反射添加其它类型

限定类型替换：如果是以下限定方式，则使用Number类型替换。要区分原始类型Obj 和泛型变量<X> 的类型。

MyClass<T extends Number>

泛型方法

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

在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到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.2f); //这两个参数一个是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.2f); //编译错误，指定了Integer，不能为Float  
        Number c = Test.<Number>add(1, 2.2f); //指定为Number，所以可以为Integer和Float  
    }  

    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}

自动类型转换

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？

JDK7中ArrayList中的get()方法源码

@SuppressWarnings("unchecked") @Override public E get(int index) {
        if (index >= size) {
            throwIndexOutOfBoundsException(index, size);
        }
        return (E) array[index];
}

看以看到，在return之前，会根据泛型变量进行强转。

instanceof关键字对比泛型类型

List<Integer> l = new ArrayList<Integer>();
System.out.println(l instanceof List); //true
System.out.println(l instanceof List<?>); //true

System.out.println(l instanceof List<Object>); //编译错误
System.out.println(l instanceof List<Long>); //编译错误

泛型是编译时就擦除的，所以上面的代码会替换成

System.out.println(l instanceof List); //true

所以使用instanceof关键字时，对比的类型加上泛型类型是多余的

泛型类型的引用传递问题

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

ArrayList<String> list3 = list2; //编译错误
ArrayList<Object> list4 = list1; //编译错误

泛型在类中静态变量和静态方法的问题

泛型类中的静态变量，不可以使用类的泛型变量。静态方法，不可以使用类的泛型变量作为返回参数或传递参数

public class Test<T> {
    public static T one;   //编译错误
    public static T get(T t){ //编译错误
        return one;
    }
}

泛型静态方法的传递参数或返回参数可以使用方法的泛型变量

public class Test<T> {
    public static <T> T get(T t){
        return t;
    }
}

因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。

Java无法创建具体泛型类型的数组

List<Integer>[] l1 = new ArrayList<Integer>[];
List<Boolean> l2 = new ArrayList<Boolean>[];

可以使用无限定通配符创建

List<?>[] l = new ArrayList<?>[10];
l[0] = new ArrayList<String>();
List<?> v = l[0];

类型擦除与多态的冲突后jvm的解决方法

参考：https://blog.csdn.net/LonelyRoamer/article/details/7868820

Bin·

发布了27 篇原创文章 · 获赞 33 · 访问量 9501

私信关注

【Java】泛型擦除详解

前言：

泛型语法

总结可接收类型

类型擦除

通过反射添加泛型类型外的其它类型