Java 泛型机制有哪些细节？使用中你会犯哪些常见错误？

Java泛型自JDK5引入以来，已成为构建健壮代码的基石。这项特性通过参数化类型将编译时类型检查与代码复用性完美结合，但背后复杂的类型擦除机制和边界约束规则也让许多开发者频频踩坑。本文将深入剖析泛型设计的核心机制，揭示开发中90%程序员都会遇到的典型错误，助你彻底规避运行时异常，写出更优雅的类型安全代码。

泛型类：通过类型参数定义类结构（如ArrayList<T>）
泛型接口：实现多态的类型约束（如Comparable<T>）
泛型方法：独立声明类型参数的函数（如<T> void print(T item)）

// 泛型类示例
public class Box<T> {
    private T content;
    public void set(T content) { this.content = content; }
}

Java泛型采用类型擦除机制实现向后兼容，编译后泛型类型会被替换为原生类型：

无界泛型（如List<T>）擦除为Object
有界泛型（如<T extends Number>）擦除为上界类型
桥接方法自动生成保证多态性

错误示例：

List rawList = new ArrayList<String>();
rawList.add(123); // 编译通过但运行时崩溃

✅ 正确做法：始终使用类型参数声明集合

List<Number> numbers = new ArrayList<Integer>(); // 编译错误
List<? extends Number> numbers = new ArrayList<Integer>(); // 正确通配符用法

错误案例：

public class Utils<T> {
    public static T createInstance() { ... } // 编译错误！
}

✅ 解决方案：改用泛型静态方法

List<String> list = new ArrayList<>();
list.getClass().getMethod("add", Object.class).invoke(list, 123); 
// 运行时成功插入Integer类型！

// 过度复杂的嵌套通配符
List<? extends List<? super Comparable<?>>> complexList;

// 推荐写法
public <T> void process(List<T> list) { ... }

public <T extends Comparable<T> & Serializable> void sort(List<T> list)

public class TypeSafeContainer {
    private Map<Class<?>, Object> map = new HashMap<>();
    
    public <T> void put(Class<T> type, T instance) {
        map.put(type, type.cast(instance));
    }
}

if(obj instanceof List<?>) { ... } // 编译警告！
// 正确类型检查方式
if(obj instanceof List) {
    for(Object item : (List<?>)obj) {
        if(!(item instanceof String)) throw ... 
    }
}

public abstract class TypeReference<T> {
    private final Type type;
    
    protected TypeReference() {
        Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }
}

public class GenericClass<T> {
    private final Class<T> type;
    
    public GenericClass(Class<T> type) {
        this.type = type;
    }
    
    public T createInstance() throws Exception {
        return type.newInstance();
    }
}

掌握Java泛型需要理解其类型擦除的本质与编译器魔法的配合机制。通过本文揭示的典型错误场景和高级应对策略，开发者可以：