结论先行:Java 泛型是编译期的类型检查工具,运行时不存在——List<String> 和 List<Integer> 在 JVM 里是同一个类。擦除换来的是与老版本字节码的兼容,代价是一批「泛型做不到」的边界。知道边界在哪,遇到泛型报错就不用猜了。

擦除到底擦了什么

编译后,类型参数被替换为边界:无边界的 T 换成 Object,T extends Number 换成 Number,使用处插入强制类型转换。所以这两行是同一个 class:

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
// 运行时两者是同一个 Class 对象:泛型参数不参与「类型身份」
System.out.println(a.getClass() == b.getClass()); // true
// 没有任何办法对 List 实例做 instanceof List<String> 判断

由此推出泛型的几条硬边界,全是擦除的直接后果:不能 new T()(运行时不知道 T 是什么);不能 new T[10];不能 T.class;泛型类的静态字段和静态方法不能使用类的类型参数(静态成员属于类,与实例的类型参数无关)。这些限制平时无感,一旦写泛型工具类或框架代码就会撞上,边界逐条对照:

操作是否可行原因替代方案
new T()否运行时不知道 T 的具体类型传 Class 反射构造,或传 Supplier
new T[10]否数组运行时校验元素类型用 ArrayList 或 Array.newInstance
T.class否类型参数已被擦除把 Class 作为方法参数传入
obj instanceof List否参数化类型运行时不存在instanceof List 后逐元素校验
静态成员引用类的 T否静态成员与实例类型参数无关类型参数下沉到方法级别

擦除还带来一个重载限制:void f(List<String>) 与 void f(List<Integer>) 不能共存——擦除后方法签名相同,编译器直接拒绝。同类问题还出现在「泛型参数不同的接口同时实现」上,报错信息指向的是桥方法签名冲突,初见时很难联想到擦除,先往这个方向排查能省很多时间。

签名其实留下了

擦除并非擦得干干净净:类和方法声明的泛型信息作为 Signature 属性保留在 class 文件里,反射可以读到。Jackson、MyBatis 能「猜到」你要反序列化成什么类型,靠的就是这个。最经典的超类型令牌(TypeToken / TypeReference)技巧:

// 匿名子类:把 Response<String> 这个参数化类型「写死」在子类签名里
Response<String> r = new Response<String>() {};

ParameterizedType type =
        (ParameterizedType) r.getClass().getGenericSuperclass();
// 泛型参数在运行时被完整找回:框架反序列化的全部秘密就在这里
System.out.println(type.getActualTypeArguments()[0]); // class java.lang.String

匿名子类把 Response<String> 这个参数化类型固化在了自己的 class 文件里,getGenericSuperclass 就能把它读出来。框架作者的必备知识,业务开发至少要认识它——你在 JSON 库里写的 new TypeReference<List<Order>>() {} 就是同一个原理。

通配符的 PECS 原则也在这里一并说清:Producer Extends(只读用 ? extends T),Consumer Super(只写用 ? super T),Collections.copy(List<? super T>, List<? extends T>) 是教科书实现。PECS 解决的是「泛型不变性太死板」的问题,与擦除是两个层面的事,但服务于同一个目标:把类型安全尽可能多地留在编译期。边界标注得越准确,编译器能帮你抓的错就越多。

桥方法:泛型多态的补丁

class MyList implements Comparable<MyList> 擦除后,接口方法变成 compareTo(Object),而你的实现是 compareTo(MyList),签名对不上。编译器自动生成一个签名为 compareTo(Object) 的桥方法,内部把参数强转后委托给你写的版本——这就是「编译器的糖衣」的实体。反编译代码看到两个同名方法时,不用慌,那是桥方法。桥方法还有个实际影响:反射枚举类的方法列表时会多出这些合成方法,做方法级拦截或监控时要识别并跳过(isBridge() 判断),否则统计口径会被污染。

自行验证很简单:MyList.class.getDeclaredMethods() 打印方法列表,能看到编译器生成的 compareTo(Object) 合成方法,同时带 bridge 与 synthetic 标记。写反射类工具(ORM、AOP 框架)时漏掉这个过滤,是常见的统计重复来源。

另一个反射视角的细节:getTypeParameters() 能拿到类型参数的声明(T 及其边界),泛型工具库生成文档、校验约束都靠它。与 Signature 属性配合,「声明处的泛型信息」比很多人想象的完整得多。

数组为什么不一样

数组是运行时确认类型的(协变):Object[] arr = new String[1]; arr[0] = Integer.valueOf(1); 会在运行时抛 ArrayStoreException;泛型是编译期确认(不变):List<Object> ls = new ArrayList<String>() 直接编译不过。历史原因导致两者规则割裂,这也是 new List<String>[10] 被禁止的原因——若允许,往里塞非 String 元素会绕过运行时类型检查,比数组更危险。对比记忆更牢:数组把类型检查推迟到每次写入时(代价摊在运行期),泛型把检查集中在编译期(运行时零成本,但失去运行时信息)。两套策略各自自洽,混用才出问题,所以泛型与数组的组合被严格限制。

这条规则的边界要记准:new List[10](原始类型数组)合法,new List<String>[10] 非法;T[] a = (T[]) new Object[10] 在泛型类内部合法但带堆污染警告,ArrayList 源码正是这么干的。看懂这三行,泛型数组的规则就闭环了。

实战:绕过擦除的正确姿势

方法签名里的类型参数能帮编译器帮你抓错,放心用;不要在运行时逻辑里「依赖」泛型类型——凡是要 T.class 的地方,把 Class 对象作为参数传进来:

// 错误写法:试图在运行时“拿到”T 的类型
public <T> T parse(String json) throws Exception {
    Class<T> clazz = T.class;          // 编译错误:T 在运行时不存在
    return objectMapper.readValue(json, clazz);
}

// 正确写法一:把 Class 对象显式传入,简单直接
public <T> T parse(String json, Class<T> clazz) throws Exception {
    return objectMapper.readValue(json, clazz);
}

// 正确写法二:元素是泛型容器时用超类型令牌(匿名子类固化签名)
List<Order> orders = objectMapper.readValue(json,
        new TypeReference<List<Order>>() {});

这是最朴素也最有效的绕擦除方案:编译期保留泛型约束做检查,运行期通过显式 Class 或 Signature 属性把类型信息「补」回来。这两类手段覆盖了 Jackson、Spring 的参数化类型解析、各种 RPC 框架的序列化实现。

还有一类常用补位手段:把类型参数换成显式令牌——<T> T read(Function<String,T> parser) 用函数对象承载「怎么构造 T」,连 Class 反射都省了。函数式接口在很多时候比 Class 令牌更轻,且天然适配 lambda,值得优先考虑。

读取未知类的泛型参数还有一种场景:框架扫描 Mapper/Repository 接口时用 getGenericInterfaces() 拿到 ParameterizedType,再解析实际类型参数——MyBatis 的 Mapper 接口绑定走的就是这条路。与超类型令牌同源:泛型信息留在「声明处」,运行期从声明处读回。

生产案例

某服务统一 HTTP 客户端封装了一个泛型方法 <T> List<T> getList(String url, Class<T> clazz),上游某天传入 Class<List> 想直接拿列表,运行时强转抛出 ClassCastException: LinkedHashMap cannot be cast to Order——JSON 库在没有元素类型信息时把每个对象反序列化成了 LinkedHashMap,编译期没人拦住这个错误签名。整改把该方法标记废弃,新签名只接受 TypeReference 参数,并在公共客户端里对「拿到的元素类型」做了启动期自检(用一个探测请求验证反序列化类型正确)。复盘的通用结论:泛型在运行时缺席,意味着所有跨「序列化边界」的类型信息都必须显式补传——API 设计时把 Class/TypeReference 定为必填参数,比事后排查 ClassCastException 便宜得多。

测试侧也有对策:为公共客户端的泛型反序列化补一条「真实下游报文样例」的单元测试,用真实 JSON 而不是手工构造的最小样本——擦除类问题恰好会在最小样本里被掩盖。