【微知识】为什么 Java 的泛型是伪泛型？

Java 的泛型被称为“伪泛型”（伪泛型）主要是因为它的实现机制是通过类型擦除（Type Erasure 来完成的，而不是像 C++ 模板那样在编译时为每个具体类型生成独立的代码。这种设计导致 Java 泛型在运行时并不存在，因此也被称为“编译时的语法糖 ”。

by emanjusaka from https://www.emanjusaka.com/archives/java-generics-difference 彼岸花开可奈何
本文为原创文章，可能会更新知识点以及修正文中的一些错误，全文转载请保留原文地址，避免产生因未即时修正导致的误导。

博客：https://www.emanjusaka.com
博客园：https://www.cnblogs.com/emanjusaka
公众号：emanjusaka的编程栈

在 Java 中，泛型被称为“伪泛型”，主要是由于其类型擦除机制。

类型擦除机制

Java 的泛型仅在编译阶段发挥作用，编译完成后，泛型类型参数会被擦除，替换为原始类型（Raw Type）。

List<Integer> list = new ArrayList<>();
list.add(10);
int value = list.get(0); // 无需强制类型转换

编译后，泛型信息会被擦除，代码在运行时等同于：

List list = new ArrayList();
list.add(10);
int value = (Integer) list.get(0); // 强制类型转换

伪泛型的具体表现

运行时类型信息缺失

List<String> list = new ArrayList<>();
System.out.println(list.getClass());// 输出 class java.util.ArrayList

尽管声明了List<String>，但在运行时，JVM 并不知道这个 List 中保存的是 String 类型。

不能创建泛型数组
```
 T[] array = new T[10]; // 编译错误：Cannot create a generic array of T
```
因为运行时不知道 T 是什么类型，所以无法确定数组的元素类型。
静态方法或字段不支持泛型类型参数
```
public class Box<T> {
    private T value;

    // 编译错误：Cannot make a static reference to the non-static type T
    public static void printStatic(Box<T> box) {
        System.out.println(box.value);
    }
}
```
这段代码会报错，因为 T 是定义在类 Box<T> 上的类型参数，而静态方法属于类本身，而不是类的某个具体实例。

类型参数（如 T）只存在于编译阶段，在运行时会被替换为 Object 或其边界类型（如 T extends Number 则替换成 Number）。

而静态方法/字段是类级别的，在类加载时就已经存在，无法依赖某个具体的泛型实例。

虽然静态方法不能使用类的泛型参数，但它们可以定义自己的泛型参数 ：

public class Box<T> {

    private T value;

    // 静态方法定义自己的泛型参数 U
    public static <U> void printStatic(Box<U> box) {
        System.out.println(box.value);
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.value = "Hello";

        Box<Integer> integerBox = new Box<>();
        integerBox.value = 123;

        Box.printStatic(stringBox);   // 输出 Hello
        Box.printStatic(integerBox);  // 输出 123
    }
}

类型转换潜在风险
1. 使用原始类型破坏类型安全
```
List<String> list = new ArrayList<>();
List rawList = list; // 警告：使用了原始类型

rawList.add(123); // 编译通过，但运行时报错！

String s = list.get(0); // 抛出 ClassCastException
```
使用原始类型 List 绕过了编译器的类型检查,向 List<String> 中插入了一个 Integer,在取值时抛出 ClassCastException。

应该避免使用原始类型，始终使用带泛型的完整类型声明。
1. 向下转型导致运行时异常
```
List<Integer> list = new ArrayList<>();
list.add(1);

Object obj = list;
List<String> stringList = (List<String>) obj; // 编译通过

String s = stringList.get(0); // 运行时报错：ClassCastException
```
  编译器无法检测到 List<Integer> 到 List<String> 的非法转换。
  
  运行时发现元素是 Integer，却试图转成 String，导致异常。
  
  尽量避免对泛型容器进行强制类型转换。如果必须转换，应先验证内容。
2. 泛型数组创建失败或引发 ClassCastException
```
public static <T> T[] toArray(T... elements) {
    return (T[]) new Object[elements.length]; // 不安全的强转
}
```
  虽然这段代码可以通过编译，但运行时可能会有类型问题：
```
String[] arr = toArray("a", "b");
// 如果内部实际是 Object[]，赋值给 String[] 会抛出 ArrayStoreException 或 ClassCastException
```
  Java 不允许直接创建泛型数组（如 new T[10]）。
  
  强制转换为 T[] 是不安全的，因为数组在运行时有类型检查。
  
  应该使用 Array.newInstance() 创建泛型数组，并传入 Class<T> 类型信息。
```
public static <T> T[] toArray(Class<T> clazz, T... elements) {
    T[] array = (T[]) java.lang.reflect.Array.newInstance(clazz, elements.length);
    System.arraycopy(elements, 0, array, 0, elements.length);
    return array;
}
```
3. 通配符使用不当导致类型错误
```
List<? extends Number> list = new ArrayList<Integer>();
list.add(new Integer(1)); // 编译错误！不能添加任何元素（除了 null）
```
  List<? extends Number> 表示“某种 Number 子类的列表”，但具体是什么不知道。
  
  所以你不能往里面添加任何具体的子类对象（比如 Integer、Double），因为不确定是否匹配。
  
  根据用途选择合适的通配符：
  - 只读不写 <? extends T>
  - 只写不读 <? super T>
  - 既读又写不使用通配符
4. 使用反射绕过泛型检查导致类型不一致
```
List<String> list = new ArrayList<>();
Method method = List.class.getMethod("add", Object.class);
method.invoke(list, 123); // 成功添加一个 Integer

String s = list.get(0); // 运行时报错：ClassCastException
```
  反射调用方法时绕过了编译器的泛型检查,添加了一个 Integer 到 List<String> 中,运行时访问时发生类型转换错误。
  
  谨慎使用反射操作泛型集合，必要时手动做类型校验。
5. 泛型类型擦除导致类型信息丢失
```
public void process(List<String> list) {}
public void process(List<Integer> list) {} // 编译错误：方法重复
```
  因为类型擦除，两个方法在运行时都是 List，所以编译器认为它们重复。
  
  不要依赖泛型参数重载方法；可以用不同的方法名区分。

总结

Java 的泛型之所以被称为“伪泛型”，是因为它在编译后会被类型擦除，泛型信息不会保留到运行时，只是用于编译期的类型检查，缺乏真正意义上的运行时泛型支持。

【微知识】为什么 Java 的泛型是伪泛型？

类型擦除机制

伪泛型的具体表现

总结

文章目录

文章分类

最新文章

最热文章

微信公众号