Java泛型核心机制与高级应用全解析

1. 泛型基础：从类型擦除说起

Java泛型的核心机制是类型擦除（Type Erasure），这是理解所有高级用法的基础。编译器在编译期间会移除所有泛型类型信息，生成的字节码中只保留原始类型（Raw Type）。比如List<String>在运行时实际是List，元素类型信息通过强制类型转换实现。

重要提示：类型擦除导致运行时无法获取泛型参数的具体类型，这是很多反射操作受限的根本原因

类型擦除带来的典型限制包括：

1. 不能创建泛型数组：new T[size]会编译报错
2. 不能使用instanceof检查泛型类型
3. 静态字段/方法不能使用类定义的泛型参数

java复制// 编译前
public class Box<T> {
    private T item;
    public void set(T item) { this.item = item; }
}

// 编译后（通过javap -c查看）
public class Box {
    private Object item;
    public void set(Object item) { this.item = item; }
}

2. 通配符的三种境界

2.1 无界通配符：<?>

表示完全未知类型，常用于方法参数中表示"不关心具体类型"。与<Object>不同，<?>更强调类型安全性。

java复制// 打印任意List的内容
void printList(List<?> list) {
    for(Object elem : list) {
        System.out.println(elem);
    }
}

2.2 上界通配符：<? extends T>

定义类型上界，表示"T或其子类"。这种协变(Covariant)特性允许读取元素（因为知道至少是T类型），但不能写入（因为不知道具体子类型）。

java复制// 处理Number及其子类的List
double sum(List<? extends Number> numbers) {
    return numbers.stream().mapToDouble(Number::doubleValue).sum();
}

2.3 下界通配符：<? super T>

定义类型下界，表示"T或其父类"。这种逆变(Contravariant)特性允许写入T类型元素，但读取时只能得到Object。

java复制// 将T类型元素放入集合
void populate(List<? super Integer> list) {
    list.add(42);  // 安全写入
    Object obj = list.get(0);  // 读取不安全，只能转为Object
}

3. 泛型方法设计模式

3.1 类型推导与<T> T模式

当方法返回值类型与参数类型相关时，使用泛型方法可以让编译器自动推导类型：

java复制// 泛型工厂方法
public static <T> T create(Class<T> clazz) throws Exception {
    return clazz.getDeclaredConstructor().newInstance();
}

// 使用时无需强制转换
String s = create(String.class);

3.2 边界与Comparable<T>应用

通过类型边界限制泛型参数的能力：

java复制// 确保类型T可比较
public static <T extends Comparable<T>> T max(List<T> list) {
    if(list.isEmpty()) throw new IllegalArgumentException();
    T max = list.get(0);
    for(T item : list) {
        if(item.compareTo(max) > 0) max = item;
    }
    return max;
}

3.3 递归类型边界

表达更复杂的类型关系，比如要求类型参数实现与自身比较：

java复制interface SelfComparable<T extends SelfComparable<T>> {
    int compareTo(T other);
}

class Student implements SelfComparable<Student> {
    @Override
    public int compareTo(Student other) { /*...*/ }
}

4. 类型安全的异构容器

突破常规泛型类限制的设计模式，用Class对象作为键来维护类型安全：

java复制public class TypeSafeContainer {
    private Map<Class<?>, Object> map = new HashMap<>();
    
    public <T> void put(Class<T> type, T instance) {
        map.put(Objects.requireNonNull(type), type.cast(instance));
    }
    
    public <T> T get(Class<T> type) {
        return type.cast(map.get(type));
    }
}

// 使用示例
TypeSafeContainer container = new TypeSafeContainer();
container.put(String.class, "Hello");
container.put(Integer.class, 42);

String s = container.get(String.class);  // 安全获取

5. 泛型与数组的恩怨情仇

由于数组是协变的（String[]是Object[]的子类）而泛型是不变的（List不是List