线上出现一条 ClassCastException,堆栈指向的代码是 String name = list.get(0);。这行代码看上去没有任何类型转换,list 也明明声明成了 List<String>。可异常信息写得很清楚:class java.lang.Integer cannot be cast to class java.lang.String。
问题不在这一行,而在更早的地方:有人用了一个没写泛型参数的 List(这种叫 raw type,原始类型),往里塞了一个整数。编译器在插入元素时没拦住,在取出元素时按 List<String> 的约定补了一次转换,于是炸在 get 这一行。这就是 Java 泛型最容易让人误解的地方:它的检查只发生在编译期,运行时的类型参数已经被擦掉了。
这篇讲四个语言特性:泛型、注解、record 和 lambda。重点不是背语法,而是弄清楚每个特性在「编译期」和「运行期」各做了什么,以及它们在什么情况下会静默失效。
泛型到底解决了什么问题
没有泛型的时候,集合只能装 Object。往里放什么都可以,取出来必须自己强转,转错了就在运行时抛 ClassCastException。泛型把「这个集合装什么类型」写进代码,让编译器提前检查,省掉大量手工转换。
常见写法有三种。List<String> 表示元素是字符串的列表;泛型方法 <T> T first(List<T> list) 里的 T 由调用时传入的参数推断;带边界的 <T extends Number> 表示 T 必须是 Number 的子类型,这样方法体里才能调用 doubleValue() 这类方法。
通配符是另一个容易读晕的地方。List<? extends Number> 表示「元素是某种 Number 子类型的列表」,你只能从里面读,不能往里写,因为编译器不知道具体是哪一种子类型;List<? super Integer> 表示「元素类型至少能装下 Integer」,你可以往里写 Integer,但读出来的类型不确定。记法是:生产者用 extends,消费者用 super。
泛型参数还有一个硬限制:不能是基本类型。写 List<int> 编译不过,必须写 List<Integer>。这意味着每次读写都可能发生装箱和拆箱,元素量大时会有额外开销。JDK 的集合框架没有为每种基本类型生成专用版本,这一点和 C# 的泛型不同。
类型擦除:运行时只剩原始类型
Java 的泛型是在 JDK 5 加入的,为了兼容之前已经编译好的代码,选择了「擦除」实现:编译器检查完类型参数,就把它们抹掉,生成的字节码里只剩下 List,需要转换的地方由编译器自动插入强制转换。所以运行时根本不知道你写的是 List<String> 还是 List<Integer>。
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass().getName());
System.out.println(b.getClass().getName());
System.out.println(a.getClass() == b.getClass());
javac -encoding UTF-8 JavaFeaturesDemo.java
java -Dstdout.encoding=UTF-8 -cp . JavaFeaturesDemo
java.util.ArrayList
java.util.ArrayList
true
两行输出的类名一模一样,第三行说明它们甚至是同一个类对象。这不是 bug,而是擦除的直接结果。由此可以推出几个日常会撞上的限制:不能用 instanceof List<String> 做运行时判断;不能创建泛型数组 new List<String>[10];不能基于泛型参数重载方法。
最后一条最隐蔽。下面这段代码编译不过,错误信息值得逐字读一遍:
static void handle(List<String> list) {}
static void handle(List<Integer> list) {}
错误: 名称冲突: handle(List<Integer>)和handle(List<String>)具有相同疑符
错误: Object 无法安全地转换为 List<String>
两个方法的参数擦除后都变成 List,签名完全相同,所以编译器认为是重复定义。第二条错误来自 instanceof List<String> 那次尝试:运行时没有泛型信息,编译器无法验证,只能拒绝。
raw type 与 unchecked 警告:编译器提醒过你
原始类型就是不带泛型参数的写法,例如 List raw = new ArrayList<String>();。它能编译,但会产生一条 unchecked 警告:使用了未经检查或不安全的操作。很多人把这条警告当成噪音,直接忽略,直到运行时抛出类型转换异常。
List raw = new ArrayList<String>();
raw.add(42);
List<String> strings = raw;
System.out.println(strings.get(0));
class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
注意异常发生的位置:add 的时候没报,赋值给 List<String> 的时候也没报,真正报错的是 get。因为擦除之后,strings.get(0) 的结果被编译器当成 String 使用,自动插入了强制转换,而那个位置实际存的是 Integer。这就是为什么堆栈看起来指向一行完全无辜的代码。
@SuppressWarnings("unchecked") 并写清楚为什么安全。把警告一路压到零,是排查这类线上问题最省时间的习惯。这种把错误类型的对象塞进泛型集合的现象有个名字,叫堆污染(heap pollution)。它不会在写入时报错,只会在某次读取时暴露,而且暴露的位置和真正写错的位置往往隔着好几个类。修法有三条:声明处补全泛型参数;确实要混装类型时改用 List<Object> 并显式判断;从外部数据转换进来时,在边界处做一次类型检查,别把校验责任推给下游。
还有两个后果值得记住。第一,静态类型检查只对「声明为泛型」的变量有效,从外部反序列化、反射创建、原生接口拿回来的数据,编译器无从验证。第二,泛型信息虽然运行时没有,但类文件的签名属性里还留着,所以可以通过反射读方法上的泛型参数类型。这也是很多框架能做参数校验和依赖注入的原因。
注解:本身不做任何事,得有人去读
注解(annotation)是贴在类、方法、字段或参数上的一段元数据,写法以 @ 开头。它最常见的用途不是「让代码自动变聪明」,而是给编译器、框架或你自己的反射代码提供信息。注解本身不会执行任何逻辑,没人读它就等于一行注释。
关键概念是保留策略 @Retention,它决定注解能活到哪个阶段。RetentionPolicy.SOURCE 只保留在源码里,编译完就丢,@Override 和 @SuppressWarnings 都是这一类;RetentionPolicy.CLASS 保留在类文件里,但运行时反射读不到,这是默认值;RetentionPolicy.RUNTIME 才会保留到运行期,反射能读到。
下面自定义一个运行期注解,并用反射读出来:
@Retention(RetentionPolicy.RUNTIME)
@interface Tag { String value(); }
@Tag("demo")
static class Annotated {}
Tag tag = Annotated.class.getAnnotation(Tag.class);
System.out.println(tag.value());
demo
如果忘了写 @Retention(RetentionPolicy.RUNTIME),getAnnotation 返回 null,后面调用 tag.value() 就是空指针。这是自定义注解最常见的坑:定义看起来没问题,运行时永远读不到。排查时先确认保留策略,再确认注解贴在目标元素上,最后确认读取的类对象是不是同一个类加载器加载的。
JDK 自带的注解正好说明了「谁来读」这件事。@Override 只在编译期工作,编译器拿它检查方法是否真的重写了父类方法,写错方法名就会报错,编译完它就没有用了。@Deprecated 被编译器读,用来在使用处给出删除线警告。@FunctionalInterface 同样在编译期检查接口是否恰好只有一个抽象方法。业务里常见的 @Test、@Transactional 则是运行期由框架反射读取,框架没扫到就等于没写。
注解还能配合 @Target 限制贴在哪里,例如只能贴方法或只能贴字段。没有写 @Target 时几乎哪里都能贴,反而容易贴错地方。读字段上的注解要用 getDeclaredField 再调 getAnnotation,读方法参数上的注解还要注意参数名在编译后可能丢失,不能只靠名字匹配。
record:只为装数据而生
record 是 JDK 16 正式加入的语法,用来声明「一组字段的不可变载体」。一行 record Point(int x, int y) {} 会自动生成构造器、x() 和 y() 访问器、equals、hashCode 和 toString。它不是普通的类,不能继承别的类,字段都是 final,类本身也是 final。
record Point(int x, int y) {}
Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
System.out.println(p1.equals(p2));
System.out.println(p1.hashCode() == p2.hashCode());
System.out.println(p1);
System.out.println(p1 == p2);
true
true
Point[x=1, y=2]
false
equals 和 hashCode 是按字段逐个比较和计算的,所以值相同就相等,但 == 仍然是 false,因为它们是两个对象。这一点和普通类一致,不要因为 equals 返回 true 就以为 == 也会 true。
record 的「不可变」是浅层的:字段不能再指向别的对象,但字段指向的对象内部照样可以改。如果字段是一个 List,往列表里加元素是允许的,而且会连带把 hashCode 改掉。
record Box(List<String> items) {}
Box box = new Box(new ArrayList<>(List.of("a")));
Set<Box> set = new HashSet<>();
set.add(box);
box.items().add("b");
System.out.println(set.contains(box));
false
为什么查不到?放进 HashSet 时按当时的字段内容算了哈希,落到某个桶里;修改列表后哈希变了,再去查就去了另一个桶,自然找不到。修法不是换集合,而是不要把可变对象放进 record,或者在构造器里做防御性拷贝,把传入的列表复制成不可变列表。
record 支持紧凑构造器,用来校验参数:record Range(int from, int to) { Range { if (from > to) throw new IllegalArgumentException("from 大于 to"); } }。这段代码会在自动赋值之前执行,校验不过就抛异常,对象根本创建不出来。适合放边界检查,不适合放复杂业务逻辑。
record 适合的场景
方法返回的多个值、配置快照、消息载体、测试里的数据构造。字段少、创建后不改、相等性按内容算,这些场景用 record 能省掉大量样板代码,而且不会漏写 hashCode。
普通类适合的场景
需要逐步构建、字段会被修改、要被框架通过无参构造器实例化、需要继承或实现复杂生命周期。这些场景硬用 record 会处处别扭,最后只能靠反射绕过限制。
判断标准很简单:这个对象创建之后还会不会变。不会变,优先 record;会变,老老实实写类。不要因为语法短就把可变模型套进 record,那等于把「哈希值会变」的隐患埋进集合里。
lambda:把行为当参数传,但有捕获限制
lambda 是一段可以传来传去的代码,写法是 (参数) -> 表达式 或 (参数) -> { 语句 }。它只能赋给「函数式接口」,也就是恰好只有一个抽象方法的接口。Runnable、Comparator、Function 都是常见例子。编译器会根据上下文推断参数类型,多数时候不用写。
lambda 能读外部的局部变量,但那个变量必须是 final 或者「实际不再变化」(effectively final)。下面的代码编译不过,错误信息和书上写的一样直接:
int count = 0;
count = 1;
Runnable r = () -> System.out.println(count);
错误: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
原因是生命周期。局部变量活在栈帧里,方法返回就没了;lambda 可能被存起来,在方法返回之后才执行。为了安全,Java 干脆要求捕获的值不可变,实际做法是把它复制进 lambda 对象。既然复制了,外部再改也影响不到 lambda,所以语法层面直接禁止。
要改外部状态,有三个办法:用只有一个元素的数组、用 AtomicInteger 这类可变容器,或者把逻辑改成返回值。数组和容器能用是因为变量本身的指向没变,变的是它指向的对象内容,绕过了「变量不可变」的限制。前两种写法可读性差,优先考虑返回值。
lambda 和匿名内部类有一个容易忽略的区别:lambda 里的 this 指向外层实例,匿名内部类里的 this 指向内部类自己。把匿名类改写成 lambda 时,如果代码里用了 this,语义会变。方法引用 String::length 是 lambda 的简写,只要参数和调用能对上就能用。
编译层面上,lambda 也不是匿名内部类的语法糖。类文件里看不到一个单独的 Lambda$1.class,而是用一条 invokedynamic 指令在第一次执行时把 lambda 绑定成接口实例。这带来两个实际影响:启动时少加载一批类;但堆栈里出现的是 lambda$main$0 这类合成方法名,排查时不如具名方法直观。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
get 那一行抛出 ClassCastException | 集合被 raw type 写入过错误类型,擦除后在取出时补转换失败 | 搜 List 不带泛型参数的声明;看编译时的 unchecked 警告 |
| 运行时读不到自定义注解 | 注解的保留策略是 CLASS 或 SOURCE,反射拿不到 | 看注解定义有没有 @Retention(RetentionPolicy.RUNTIME) |
| 两个不同的泛型方法报「名称冲突」 | 擦除后参数类型相同,JVM 无法区分 | 看方法签名擦除后的原始类型;改用不同的方法名或加一个区分参数 |
instanceof List<String> 编译失败 | 运行时没有泛型参数信息 | 先判断 instanceof List,再逐个元素检查类型 |
record 放进 HashSet 后查不到 | record 里的可变字段被修改,hashCode 跟着变了 | 检查字段指向的对象是否可变;构造时做防御性拷贝 |
| lambda 里改外部变量编译失败 | 捕获的局部变量不是 effectively final | 看变量是否在 lambda 之后还有赋值;改成返回值或可变容器 |
| 匿名类改成 lambda 后行为变了 | 两者的 this 指向不同 | 搜 lambda 体内的 this 和 super;需要内部类语义就保留匿名类 |
| 反序列化后泛型校验没生效 | JSON 库按擦除后的类型构造对象,运行时不知道元素类型 | 看反序列化时传的 TypeReference 或 JavaType 是否带了完整泛型 |
这张表的核心只有一句:泛型问题往「擦除」上想,注解问题往「保留策略」上想,record 问题往「可变字段」上想,lambda 问题往「捕获」上想。四个特性各有各的静默失效方式,现象却都像普通业务 bug。
边界与代价
这四个特性都在解决真实问题,但没有一个是「加上就更好」的。它们各自的限制如下:
- 泛型只有编译期:运行时拿不到元素类型,不能做泛型数组、不能按泛型参数重载、不能靠
instanceof判断。需要运行时类型信息时,只能额外传Class对象或TypeReference。 - 泛型不能装基本类型:
List<Integer>会有装箱开销。对性能敏感的大循环,基本类型数组往往比泛型集合更合适。 - 注解依赖读取方:写一个注解不会自动产生任何行为。要么编译器认,要么框架认,要么你自己写反射代码认。没有读取方的注解只是文档。
- 反射读注解有成本:启动时扫描大量类、反复调用
getAnnotation会拖慢启动。缓存读到的结果,别在每次请求里重新扫。 record不适合可变模型:字段全为final,没有无参构造器,也不支持继承。传统 ORM 框架、需要逐步构建的对象、需要携带大量可变状态的 DTO,都不适合硬套record。- lambda 捕获受限:只能读 effectively final 的局部变量;抛受检异常时,函数式接口必须声明该异常;调试时堆栈里看到的是合成方法,名字不如普通方法直观。
- 注解处理有额外一轮编译:注解处理器在编译期扫描和生成代码,项目大了会明显拖慢构建;运行期反射读注解同样有开销,能缓存就缓存。
还有一个容易被忽略的代价:这些语法糖让代码更短,但错误信息不一定更清楚。擦除导致的异常出现在离错误很远的位置,lambda 的堆栈里会出现 lambda$main$0 这样的名字。写的时候省下的字,排查时要还回去。团队里约定「不忽略 unchecked 警告、注解必须写保留策略」,比事后查线上便宜得多。
当天能自己验证的练习
- 写两个列表,一个声明
List<String>,一个声明List<Integer>,打印它们的getClass().getName(),确认运行时类名完全相同。 - 写一个 raw type 的
List,先放字符串再放整数,然后按List<String>取第二个元素,观察异常发生在哪一行、信息里提到了哪些类。 - 自定义一个注解,先不写
@Retention,用反射读取并打印结果;再加上RetentionPolicy.RUNTIME重新编译,对比两次输出。 - 定义一个含
List字段的record,放进HashSet后修改列表内容,再调用contains,确认返回 false,并解释哈希值变化。 - 写一个 lambda,先捕获一个之后会被重新赋值的局部变量,记录编译器报错原文;再把变量改成只赋值一次,确认编译通过并能打印捕获到的值。
小结
三句话收一下:泛型是编译期的检查,运行时被擦除,raw type 会把错误推迟到取元素的那一刻;注解本身不做事,保留策略决定反射能不能读到;record 自动生成相等性但只保证浅层不可变,lambda 只能捕获不再变化的局部变量。
下一篇进入集合与 Stream。泛型是集合的骨架,今天看到的 List<String> 只是开始;真正让项目出问题的,往往是遍历时删元素、视图随原集合变化、Stream 没有终止操作这些运行时行为。