泛型擦除和泛型使用限制

一、泛型擦除

1.概念

泛型是Java1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为--类型擦除。

示例：

public class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> integerArrayList = new ArrayList<>();
        ArrayList<String> stringArrayList = new ArrayList<>();

        System.out.println(integerArrayList.getClass().getSimpleName());
        System.out.println(stringArrayList.getClass().getSimpleName());

        System.out.println(integerArrayList.getClass() == stringArrayList.getClass());
    }
}

运行结果：

ArrayList
ArrayList
true

虽然在编译阶段integerArrayList指定的泛型为Integer类型，stringArrayList指定的泛型为String类型，看上去似乎是不同类型，但是在编译完成之后这些泛型信息都被擦除掉了，它们本质上都是ArrayList类型，这个擦除的过程就是类型擦除。

2.分类

• 无限制类型擦除

示例：

class Erasure<T> {
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }
}

public class Test {
    public static void main(String[] args) {
        Erasure<String> erasure = new Erasure<>();
        // 利用反射，获取Erasure类的字节码文件的Class类对象
        Class<? extends Erasure> erasureClass = erasure.getClass();
        // 获取所有的成员变量
        Field[] declaredFields = erasureClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            // 打印成员变量的名称和类型
            System.out.println(declaredField.getName() + ":" + declaredField.getType().getSimpleName());
        }
    }
}

 运行结果：

key:Object

• 有限制类型擦除

 示例：

class Erasure<T extends Number> {
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }
}

public class Test {
    public static void main(String[] args) {
        Erasure<Integer> erasure = new Erasure<>();
        // 利用反射，获取Erasure类的字节码文件的Class类对象
        Class<? extends Erasure> erasureClass = erasure.getClass();
        // 获取所有的成员变量
        Field[] declaredFields = erasureClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            // 打印成员变量的名称和类型
            System.out.println(declaredField.getName() + ":" + declaredField.getType().getSimpleName());
        }
    }
}

运行结果：

key:Number

• 擦除方法中类型定义的参数

 示例：

class Erasure<T extends Number> {
    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    /**
     * 泛型方法
     * @param t
     * @return
     * @param <T>
     */
    public <T extends List> T show(T t) {
        return t;
    }
}

public class Test {
    public static void main(String[] args) {
        Erasure<Integer> erasure = new Erasure<>();
        // 利用反射，获取Erasure类的字节码文件的Class类对象
        Class<? extends Erasure> erasureClass = erasure.getClass();

        // 获取所有的方法
        Method[] declaredMethods = erasureClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            // 打印方法名和方法的返回值类型
            System.out.println(declaredMethod.getName() + ":" + declaredMethod.getReturnType().getSimpleName());
        }
    }
}

运行结果：

getKey:Number
show:List
setKey:void

• 桥接方法

 示例：

interface Info<T> {
    T info(T t);
}

class infoImpl implements Info<Integer> {

    @Override
    public Integer info(Integer value) {
        return value;
    }
}

public class Test {
    public static void main(String[] args) {
        Class<infoImpl> infoClass = infoImpl.class;
        Method[] declaredMethods = infoClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName() + ":" + declaredMethod.getReturnType().getSimpleName());
        }
    }
}

运行结果：

info:Integer
info:Object

二、泛型使用限制

由于类型擦除的隐蔽性，泛型的使用存在以下约束限制：

1. 不能用泛型类型参数创建实例对象，如T object = new T()，由于类型擦除原理，编译时所有泛型类型都会变为相应的原始类型，这时泛型T是没有类型的，是无效的。
2. 不能使用泛型类创建数组，如T[ ] elements = new T[capacity]. 如果先创建一个类型数组而后转型为Object，会导致数组创建失败和类型擦除问题。
3. 不能将泛型用在静态的上下文中，泛型类的所有实例均有相同的运行时类，这个泛型类的静态变量和静态方法被它的所有实例所共享，因此在泛型类中定义的静态变量和静态的泛型方法是非法的，会出现程序安全隐患。
4. 不能用基本数据类型替换类型参数，如List<int>，其中int为基本类型，必须使用其包装类型Integer。
5. 异常类不能使用泛型，否则将泛型用在异常捕获中将会出现编译错误。