Java 泛型：类型擦除与通配符

泛型是 Java 中一项强大但容易被误解的特性。它允许在编写代码时使用"类型参数"，让同一段代码能够处理不同类型的对象，同时保持编译时的类型安全。许多开发者使用泛型多年，却对其底层原理——类型擦除——知之甚少。本文将深入探讨泛型的核心机制，帮助你写出更健壮的代码。

为什么需要泛型？

在泛型出现之前，Java 集合框架存在一个经典问题：类型信息丢失。

// Java 1.4 时代的写法
List list = new ArrayList();
list.add("hello");
list.add(123);  // 编译通过，但运行时会出问题

String str = (String) list.get(1);  // ClassCastException

上述代码在编译时没有任何错误提示，但在运行时抛出 ClassCastException。这类错误往往在生产环境中才被发现，排查困难。泛型的核心价值就在于此——将运行时的问题提前到编译期发现。

// 使用泛型后
List<String> list = new ArrayList<>();
list.add("hello");
// list.add(123);  // 编译错误！类型不匹配

String str = list.get(0);  // 无需强转，类型已保证

类型擦除：泛型的真相

理解类型擦除是掌握 Java 泛型的关键。Java 的泛型实现采用了"类型擦除"策略，这意味着泛型信息仅在编译阶段存在，在运行时会被完全移除。

擦除机制的三个规则

编译器在处理泛型时，会按照以下规则进行擦除：

1. 将类型参数替换为上界或 Object

如果没有指定上界，类型参数会被替换为 Object。

public class Box<T> {
    private T content;

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }
}

编译后等价于：

public class Box {
    private Object content;

    public Object getContent() {
        return content;
    }

    public void setContent(Object content) {
        this.content = content;
    }
}

2. 插入类型强制转换

在读取泛型值时，编译器会自动插入类型转换。

// 源代码
String content = box.getContent();

// 编译后等价于
String content = (String) box.getContent();

3. 维持多态性

如果类型参数有上界，编译器会使用类型转换来维持多态性。

public class NumberBox<T extends Number> {
    private T value;

    public double getAsDouble() {
        return value.doubleValue();
    }
}

编译后 getAsDouble 方法内部会添加 (Number) value 的转换。

擦除导致的后果

类型擦除会产生一些看似"反直觉"的现象。

// 无法在运行时判断泛型类型
List<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();

System.out.println(stringList.getClass() == intList.getClass());  // true，都是 ArrayList

由于类型擦除，stringList 和 intList 在运行时的 class 完全相同。这解释了为什么不能创建泛型数组、不能使用 instanceof 检查泛型类型。

// 以下操作均不合法
if (obj instanceof List<String>)  // 编译错误
List<String>[] array = new ArrayList<String>[10];  // 编译错误

通配符：灵活性的关键

通配符 ? 让泛型类型之间的关系更加灵活，是处理"未知类型"场景的利器。

无界通配符：?

当方法仅读取泛型对象而不关心具体类型时，使用无界通配符。

public void printList(List<?> list) {
    for (Object elem : list) {
        System.out.println(elem);
    }
}

调用时允许传入任意类型的 List：

List<String> strings = Arrays.asList("a", "b");
List<Integer> ints = Arrays.asList(1, 2);
printList(strings);  // OK
printList(ints);     // OK

上界通配符：? extends T

当方法仅从泛型对象中读取数据，且类型是 T 或 T 的子类时，使用上界通配符。

public double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number num : list) {
        sum += num.doubleValue();
    }
    return sum;
}

这个方法可以处理 List<Integer>、List<Double>、List<Float> 等任何 Number 子类的列表。

关键限制：不能向列表中写入数据（null 除外）

List<? extends Number> nums = new ArrayList<Integer>();
nums.add(5);      // 编译错误！
nums.add(3.14);   // 编译错误！
nums.add(null);   // 唯一合法操作

原因在于编译器无法确定 nums 实际指向的是 List<Integer>、List<Double> 还是其他类型，添加任何非 null 值都可能导致类型安全问题。

下界通配符：? super T

当方法需要向泛型对象中写入数据，且类型是 T 或 T 的父类时，使用下界通配符。

public void addNumbers(List<? super Integer> list) {
    list.add(10);
    list.add(20);
    // list.add(3.14);  // 编译错误！
}

这里 list 可以是 List<Integer>、List<Number> 或 List<Object>，向其中添加 Integer 是安全的。

关键限制：读取时只能得到 Object

List<? super Integer> list = new ArrayList<Number>();
list.add(10);
Object obj = list.get(0);  // 只能保证是 Object 类型

通配符选择原则

// 生产者：提供数据
public void processAll(Container<? extends Data> container) {
    Data data = container.get();  // 安全读取
}

// 消费者：存储数据
public void saveAll(Container<? super Data> container) {
    container.set(new Data());    // 安全写入
}

常见问题与最佳实践

类型擦除与桥接方法

当子类继承或实现泛型父类/接口时，编译器会自动生成"桥接方法"以维持多态性。

// 父类
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

// 子类
public class StringIntPair implements Pair<String, Integer> {
    @Override
    public String getKey() { return "key"; }

    @Override
    public Integer getValue() { return 0; }
}

编译后，JVM 看到的 StringIntPair 实现了两个桥接方法：

public class StringIntPair implements Pair<String, Integer> {
    public String getKey() { return "key"; }
    public Integer getValue() { return 0; }

    // 编译器生成的桥接方法
    public Object getKey() { return getKey(); }
    public Object getValue() { return getValue(); }
}

这是为什么反射 API 有时能看到"额外"方法的原因。

泛型数组的限制

Java 不允许创建泛型数组，这一限制正是类型擦除的体现。

// 以下均不合法
List<String>[] array = new ArrayList<String>[10];  // 编译错误
T[] createArray(Class<T> type, int size) {         // 方法内无法创建 T[]
    return (T[]) new Object[size];
}

如果允许创建泛型数组，类型擦除会导致运行时类型检查失效，产生安全漏洞。

善用类型推导

Java 7 引入了菱形操作符 <>，让代码更简洁。

// 冗长
Map<String, List<Map.Entry<String, Integer>>> map = 
    new HashMap<String, List<Map.Entry<String, Integer>>>();

// 简洁（菱形操作符）
Map<String, List<Map.Entry<String, Integer>>> map = 
    new HashMap<>();

避免 raw types

永远不要在泛型代码中使用 raw types（省略类型参数的泛型），这会重新引入类型不安全问题。

// 避免
List list = new ArrayList();  // raw type

// 推荐
List<String> list = new ArrayList<>();

如果必须使用 raw types（如与遗留代码交互），使用 @SuppressWarnings("unchecked") 标注，并确保理解潜在风险。

实战：构建类型安全的 API

理解泛型原理后，可以设计出更加类型安全的 API。

public abstract class EventBus<E extends Event> {
    private final List<Consumer<E>> handlers = new ArrayList<>();

    public void register(Consumer<E> handler) {
        handlers.add(handler);
    }

    public void publish(E event) {
        handlers.forEach(handler -> handler.accept(event));
    }
}

// 具体事件类型
public class UserEvent {
    private final String userId;
    private final String action;

    public UserEvent(String userId, String action) {
        this.userId = userId;
        this.action = action;
    }

    public String getUserId() { return userId; }
    public String getAction() { return action; }
}

// 使用
EventBus<UserEvent> userBus = new UserEventBus();
userBus.register(event -> {
    System.out.println("User " + event.getUserId() + " performed " + event.getAction());
});
userBus.publish(new UserEvent("123", "login"));

上述设计确保了事件处理器只能处理其声明类型的事件，编译期即可发现类型错误。

类型擦除是 Java 泛型设计中的重要权衡——它保持了向后兼容性（与非泛型代码共存），同时在编译阶段提供类型安全。理解这一机制，你就能更准确地预测泛型行为，避免常见的陷阱，写出更加健壮和可维护的代码。