什么是 Java 的类型擦除

什么是类型擦除（Type Erasure）？

类型擦除（Type Erasure）是 Java 编程语言中泛型（Generics）的一部分，它是指在编译时将泛型类型转换为原始类型，从而在运行时移除类型参数信息的过程。类型擦除的设计目的是为了兼容 Java 语言的早期版本，使得泛型可以在 Java 1.5 之前的字节码上运行，同时不需要对 JVM 进行重大更改。

类型擦除的工作原理

为了理解类型擦除的工作原理，需要从 Java 编译器和 JVM 的角度来分析。Java 编译器在编译包含泛型的代码时，会在编译阶段执行类型擦除操作，将所有泛型类型参数替换为它们的非泛型超类型（通常是 Object），并插入必要的类型转换。类型擦除使得泛型的类型参数在编译后不保留在生成的字节码中，因此在运行时是不可见的。

编译器视角

考虑下面一个简单的泛型类：

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

在这个例子中，T 是一个类型参数，表示 Box 可以存储任何类型的对象。在编译时，Java 编译器会将这个泛型类转换为一个使用 Object 的非泛型类，如下所示：

public class Box {
    private Object item;

    public void setItem(Object item) {
        this.item = item;
    }

    public Object getItem() {
        return item;
    }
}

此外，在类型擦除过程中，编译器还会在必要时插入类型转换操作。例如，如果你使用 Box<String>，那么编译器在编译时会将 getItem() 方法的返回值强制转换为 String 类型：

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello, World!");
String item = (String) stringBox.getItem();  // 类型转换在编译时插入

JVM 和字节码视角

从 JVM 的角度来看，类型擦除意味着 JVM 并不需要知道泛型类型参数。因为在字节码中，这些类型参数已经被擦除，转而使用通用的 Object 类型或其他非泛型超类型。这样做的主要好处是可以保证与旧版本 Java 代码的二进制兼容性。

在字节码中，泛型方法和类会表现得像是普通的方法和类。举个例子，上面 Box<T> 类的 setItem 和 getItem 方法在字节码中看起来会像这样：

// setItem 方法的字节码
public void setItem(java.lang.Object);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #2   // Field item:Ljava/lang/Object;
       5: return

// getItem 方法的字节码
public java.lang.Object getItem();
    Code:
       0: aload_0
       1: getfield      #2   // Field item:Ljava/lang/Object;
       4: areturn

在这些字节码中，item 字段的类型是 java.lang.Object，而不是泛型类型 T。这反映了类型擦除的结果——在运行时，泛型类型参数已经完全被移除了。

为什么需要类型擦除？

理解类型擦除的原因需要回到 Java 语言的演变历史。Java 泛型是在 Java 1.5 引入的，但在此之前，Java 已经有了大量使用非泛型集合类和方法的代码库。为了让新引入的泛型特性能够无缝地与现有代码库和 JVM 兼容，Java 设计者选择了类型擦除。

类型擦除的主要目标包括：

1. 二进制兼容性：使得新版本的 Java 代码可以与旧版本的 Java 二进制文件（class 文件）一起运行，而无需重新编译旧代码。这意味着现有的 JVM 不需要做任何更改来支持泛型。
2. 源代码兼容性：旧的 Java 源代码能够在新版本的编译器中编译并运行，而无需对代码进行修改。
3. 减少 JVM 复杂度：通过在编译时移除类型参数，JVM 无需处理泛型的复杂性，从而简化了 JVM 的设计和实现。

类型擦除的局限性和挑战

虽然类型擦除为向后兼容性提供了便利，但它也带来了一些局限性和挑战，特别是在开发泛型代码时。以下是一些主要的局限性：

1. 运行时类型检查的问题

由于泛型类型参数在运行时被移除，因此无法直接检查泛型类型。例如，无法在运行时检查一个泛型 List<T> 的具体类型参数：

List<String> stringList = new ArrayList<>();
if (stringList instanceof List<String>) {  // 编译错误
    // ...
}

这个检查在编译时会报错，因为类型擦除后，List<String> 和 List<Integer> 在运行时是相同的（即 List<Object>），因此 instanceof 检查无法区分它们。

2. 不能创建泛型数组

由于类型擦除的存在，Java 中不能创建泛型数组。这是因为数组在 Java 中是协变的，即 String[] 是 Object[] 的子类型，而泛型在类型擦除后会变成相同的类型，因此可能会导致运行时的类型安全问题：

List<String>[] listArray = new List<String>[10];  // 编译错误

为了避免这种问题，Java 语言禁止创建泛型数组。

3. 类型信息丢失

由于类型擦除的存在，泛型类型参数的信息在运行时会丢失。这意味着在一些情况下，开发者无法获得原始的类型信息。例如，使用反射时，无法获取泛型类的实际类型参数：

Box<String> stringBox = new Box<>();
Type type = stringBox.getClass().getGenericSuperclass();
System.out.println(type);  // 输出 class java.lang.Object

在这个例子中，type 变量无法反映 Box<String> 的实际类型参数，只能获取到被擦除后的类型 Object。

类型擦除的真实案例：自定义集合类

为了更好地理解类型擦除的实际影响，我们来看一个真实的案例，展示如何在没有类型擦除和泛型支持的情况下创建一个自定义集合类，以及在有泛型支持和类型擦除情况下的变化。

无泛型的集合类

在 Java 1.5 之前，开发者通常使用 Object 来创建可以存储任何类型对象的集合类。例如，一个简单的自定义集合类可能如下所示：

public class CustomCollection {
    private Object[] items;
    private int size;

    public CustomCollection(int capacity) {
        items = new Object[capacity];
        size = 0;
    }

    public void add(Object item) {
        items[size++] = item;
    }

    public Object get(int index) {
        return items[index];
    }
}

这个类可以存储任何类型的对象，但在使用时需要手动进行类型转换：

CustomCollection collection = new CustomCollection(10);
collection.add("Hello");
String item = (String) collection.get(0);

在这种情况下，类型转换错误可能在运行时出现，并导致 ClassCastException 异常。

使用泛型的集合类

引入泛型后，我们可以使用类型参数来创建类型安全的集合类：

public class CustomCollection<T> {
    private T[] items;
    private int size;

    public CustomCollection(int capacity) {
        items = (T[]) new Object[capacity];  // 类型转换
        size = 0;
    }

    public void add(T item) {
        items[size++] = item;
    }

    public T get(int index) {
        return items[index];
    }
}

这个版本的集合类使用了类型参数 T，允许我们在编译时确保类型安全：

CustomCollection<String> collection = new CustomCollection<>(10);
collection.add("Hello");
String item = collection.get(0);  // 不需要类型转换

在编译时，Java 编译器会进行类型擦除，将 T 替换为 Object，并插入必要的类型转换。

类型擦除与泛型方法

类型擦除不仅适用于泛型类，也适用于泛型方法。泛型方法允许方法定义中使用类型参数，从而在方法内部应用类型安全。例如：

public <T> T process(T input) {
    // 处理逻辑
    return input;
}

在编译时，这个泛型方法也会进行类型擦除。