Java函数的泛型与类型擦除

Java中的泛型是一种非常有用的机制，它可以在编译期间对代码进行类型检查，避免类型转换错误和运行时异常。Java中的泛型是通过类型参数来实现的，例如：

public class GenericClass<T> {
    private T data;
    public GenericClass(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}

这里的泛型类型参数T可以在实例化GenericClass对象时指定具体的类型，例如：

GenericClass<String> genericString = new GenericClass<>("Hello World!");
String dataString = genericString.getData();

GenericClass<Integer> genericInteger = new GenericClass<>(42);
int dataInteger = genericInteger.getData();

在编译期间，Java编译器会将泛型类型转换成实际类型，这个过程被称为类型擦除。即编译器实际上会把GenericClass类型转换为Object类型。

在运行时，Java虚拟机无法区分泛型类型参数T的实际类型，因为类型擦除过程中，所有T类型信息都被擦除了。因此，泛型类型参数T在运行时也会被转换成Object类型。

例如，对于上面的GenericClass类，它在实例化时会被类型擦除成如下形式：

public class GenericClass {
    private Object data;
    public GenericClass(Object data) {
        this.data = data;
    }
    public Object getData() {
        return data;
    }
}

类型擦除的影响

类型擦除对泛型类型参数T的使用产生了许多限制和影响，如下所示：

1. 不能使用基本类型作为泛型类型参数

// 错误的示例
GenericClass<int> genericInt = new GenericClass<>(42);

这是因为在类型擦除过程中基本类型会被装箱成相应的包装器类型，而包装器类型是一个引用类型，无法作为泛型类型参数。

2. 不能在泛型类中使用T类型参数的数组

// 错误的示例
public class GenericClass<T> {
    private T[] data;
    public GenericClass(T[] data) {
        this.data = data;
    }
    public T[] getData() {
        return data;
    }
}

在类型擦除过程中，T[]会被转换为Object[]，这样就无法保证数组元素的类型安全，可能会导致ClassCastException异常。

解决这个问题的方法是使用ArrayList或其他集合类型来存储泛型类型参数T的元素。

3. 不能在静态方法或静态变量中使用泛型类型参数

public class GenericClass<T> {
    private static T data; // 错误的示例
    public static T getData() { // 错误的示例
        return data;
    }
}

在类型擦除过程中，泛型类型参数T被转换成Object类型，而静态方法或静态变量是与类相关而不是对象相关的，所以无法推断T的实际类型。

解决这个问题的方法是使用不带泛型类型参数的静态方法或静态变量。

4. 不能在泛型类中使用类型参数T的类型为泛型类型参数的类

// 错误的示例
public class GenericClass<T> {
    private T data;
    public void setData(T data) {
        this.data = data;
    }
    public <E> void printData() { // 错误的示例
        System.out.println(data instanceof E); // 错误的示例
    }
}

在类型擦除过程中，泛型类型T会被转换成Object类型，而类型参数E也会被转换成Object类型，无法进行类型检查。

解决这个问题的方法是使用类型通配符来代替类型参数。

类型通配符

类型通配符是一种只使用一次的泛型类型参数，用于表示任何类型。类型通配符使用问号?来表示，例如：

public void printData(GenericClass<?> generic) {
    System.out.println(generic.getData());
}

这里的?代表任何类型，因此可以接受任意类型的GenericClass对象。

类型通配符还可以使用extends或super关键字来限制类型的范围。例如：

public void printData(ArrayList<? extends Number> list) {
    for (Number n: list) {
        System.out.println(n);
    }
}

这里的? extends Number代表任何继承自Number类的类型，因此可以接受任何类型的Number子类的集合对象。

类型检查和类型转换

在使用泛型时，还需要注意类型检查和类型转换的问题。例如：

public class GenericClass<T> {
    private T data;
    public void setData(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}

GenericClass<Integer> generic = new GenericClass<>();
generic.setData(42);
Object obj = generic.getData(); // 正确的示例
String str = generic.getData(); // 错误的示例
Integer i = (Integer) generic.getData(); // 正确的示例

以上代码中，调用getData方法返回泛型类型参数T的值，可以将返回值保存到Object类型的变量中，但如果保存到String类型的变量中，就会出现编译错误。因此，需要进行类型转换才能正确使用。

总结

泛型是Java中一个非常有用的机制，它可以在编译期间进行类型检查，避免类型转换错误和运行时异常。但在类型擦除的过程中，会出现一些限制和影响，需要特别注意。同时，还需要注意类型检查和类型转换的问题。