1. 第30条到底在讲什么:泛型方法的价值定位
1.1 从"先转型后使用"的老代码说起
在进入第30条之前,我先带大家回忆一下没有泛型方法时的日子。假设你想写一个工具方法,从一个列表里取出最大值,在没有泛型的那会儿,代码长这样:
java复制public static Object max(List list) {
Object max = list.get(0);
for (Object item : list) {
if (((Comparable) item).compareTo(max) > 0) {
max = item;
}
}
return max;
}
调用方拿到的返回值是Object,接下来就是无休止的向下转型。麻烦在于转型这件事,编译器在编译期拦不住你,只在运行期才告诉你“类型对不上”。更糟的是,万一调用方传进来一个根本不能比较的列表,这段代码会在运行期直接抛ClassCastException。
泛型方法解决的就是这类问题:把“元素类型”作为方法的类型参数,让编译器在编译期就去校验、推断和插入转换。它不仅能消除强转的样板代码,更重要的是把类型的正确性证明前移到了编译阶段。对于任何写过三五年Java的人来说,这个价值不需要我多解释——越早暴露的问题,修复成本越低。
第30条英文原文标题是“Prefer Generic Methods”,中文翻译是“优先考虑泛型方法”。注意这里的措辞,不是“必须使用”,而是“优先考虑”。这意味着它是一条实践原则,而不是一条强制禁令。具体来说,当你的方法签名的参数或者返回值里出现了不该出现的具体类型,或者需要靠调用方强转才能接住返回值,这就是一个泛型方法的“候选信号”。
1.2 泛型方法为什么比泛型类更容易上手
很多人学Java泛型时,第一反应是先接触泛型类,比如List<T>、Map<K, V>。但写业务代码的时候,你会发现自己整天在写具体的类,很少去定义一个全新的泛型类。反而是泛型方法更常见——因为一个类里只要有一个方法需要类型参数化,这个方法就可以单独声明泛型,完全不必把整个类都改造掉。
泛型方法的意思是:在方法的修饰符和返回值之间,多了一个类型参数声明,用尖括号括起来。
java复制public static <T> T getMiddle(T... args) {
return args[args.length / 2];
}
调用时跟普通方法一模一样,多数情况下不需要显式传类型参数,编译器自动推断。原因很简单:泛型类的类型参数是在实例化时确定的,泛型方法的类型参数是在调用时确定的。类被new出来之后,类型参数就钉死了;方法每一次调用,都可以有自己独立的类型参数解析。这种灵活度让泛型方法成为了静态工具方法、工厂方法、策略入口的天然选择。
1.3 泛型方法解决的三个核心痛点
第一个痛点是类型安全。比如你写一个过滤函数,接收一个集合并返回同类型的新集合。用Object写,调用方收到List
第二个痛点是消除强转。IDE里天天见的那种(User) session.get("user")就是典型的非泛型设计。一旦接口设计成<T> T get(String key),调用方直接写User user = session.get("user")就完事,强转由编译器悄悄插入。
第三个痛点是让API能表达更精确的约束。比如你写一个方法,要求传入的参数必须实现了Comparator且类型匹配,这在非泛型时代根本表达不了,只能靠文档约定和运行期错误来兜底。泛型方法的递归类型边界(recursive type bound)可以把这种约束写进方法签名,让编译器来把关。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 泛型方法的三类核心应用模式
2.1 静态工具方法:让API自带类型推断
《Effective Java》第30条开篇就强调:静态工具方法特别适合声明为泛型方法。如果你翻过JDK的Collections类,会发现里面几乎所有静态方法都是泛型方法。
以最经典的Collections.max为例:
java复制public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
这个签名里有三处泛型细节值得停下来多看两眼。第一,T extends Comparable<? super T>表示T类型必须是可比较的,而且它比较的父类型不能超过T自身;第二,Collection<? extends T>表示传入的集合元素类型必须是T的子类型;第三,返回值直接是T,调用方拿到之后零强转。
我在实际工程里见过太多人自己造这种轮子,比如写一个“批量反转list”的工具类:
java复制public class ListUtils {
public static <T> List<T> reversed(List<T> source) {
List<T> result = new ArrayList<>(source);
Collections.reverse(result);
return result;
}
}
就这么一个简单方法,带来的收益是调用处可以直接List<String> reversed = ListUtils.reversed(original),不用写任何强转。如果当初图省事写List reversed(List source),调用方的返回值就必须强转,而且编译器看不见任何问题,只有等运行期ClassCastException冒出来才追悔莫及。
写静态工具方法的时候,我给自己定了几条规矩,供大家参考:
- 参数里有
Collection、List、Map等容器类型时,默认就要考虑泛型化 - 返回值的类型和参数的某个类型相关时,必须用类型参数绑定
- 工具方法是给别人复用的,类型参数多一点没关系,但不要为了泛型而泛型
2.2 泛型单例工厂:只建一个对象,服务所有类型
这是第30条里最精巧的一个模式,初看会觉得反直觉,理解了之后会直呼“妙啊”。场景是这样的:有些类本身是无状态的,比如函数接口、比较器、逆序操作。这些对象不需要保存任何与特定类型相关的状态,逻辑对所有类型完全一致。但从API的角度看,调用方希望拿到的又是带类型的。
典型例子就是Collections.reverseOrder()。它返回的Comparator,既能对String排序,也能对Integer排序,本质上逻辑就是“比较两个对象的自然顺序并取反”。如果这个类声明成Comparator<Object>,调用方拿到的就是Comparator<Object>,想当Comparator<String>用还得转一下。
泛型单例工厂的解决思路是:内部只维护一个Object类型的单例对象,对外通过泛型方法做一次无检查转换(unchecked cast)再返回。因为类型擦除的存在,这个转换在运行期根本不存在,所以安全。
java复制public class Collections {
private static final Comparator<Object> REVERSE_ORDER = (Comparator<Object>) (c1, c2) ->
((Comparable<Object>) c2).compareTo(c1);
@SuppressWarnings("unchecked")
public static <T> Comparator<T> reverseOrder() {
return (Comparator<T>) REVERSE_ORDER;
}
}
理解这个模式的关键,是理解“为什么强转是安全的”。Comparator(Comparator<T>)虽然被@SuppressWarnings压住了,但它实际上是安全的,因为REVERSE_ORDER这个实现本身不关心T是什么。它做的事情就是把两个对象按自然顺序比大小,Int类型比的是int值,String类型比的是字典序。类型参数T在这里并不会影响任何逻辑分支,所以无论T被替换成哪种类型,行为都不会出问题。
我在团队里推广这个模式时,经常被人问一个问题:“为什么不直接每次new一个Comparator出来?反正创建开销也不大。”问题不在于性能,而在于对象标识和语义。单例工厂表达的是“这是一个无状态的、类型无关的通用逻辑”这个设计意图。当你在代码评审里看到同一个无状态策略对象被反复new来new去,这本身就是坏味道——它暗示设计者没有想清楚这个策略的本质。
2.3 递归类型边界:把类型约束写进签名里
递归类型边界(recursive type bound)这个名字听起来很吓人,其实想表达的是:类型参数的边界条件里引用了自己。最常见的场景就是Comparable。
第30条里举的max方法例子:
java复制public static <E extends Comparable<E>> E max(Collection<E> c) {
if (c.isEmpty()) {
throw new IllegalArgumentException("Empty collection");
}
E result = null;
for (E e : c) {
if (result == null || e.compareTo(result) > 0) {
result = e;
}
}
return result;
}
这里的E extends Comparable<E>说明了三件事:E必须可以比较;E比较的对象必须是它自己;E的compareTo方法接收的参数类型和当前元素类型一致。最后一个约束很关键,它堵死了“拿苹果和橘子比”这种场景。
有人会问,为什么边界要写成Comparable<E>而不是Comparable<? super E>?这其实是个更精细的问题。在Collections源码里,sort方法用的就是T extends Comparable<? super T>:
java复制public static <T extends Comparable<? super T>> void sort(List<T> list)
这涉及Java泛型的继承规则。假设有一个类Dog extends Animal implements Comparable<Animal>。Dog实现了ComparableComparable<Dog>,Dog就传不进去;但写成Comparable<? super Dog>,就能接受Comparable
我在实际写代码时的选择标准是:如果确定元素类型只和自己比,用E extends Comparable<E>;如果有可能继承自一个实现了Comparable<父类>的父类,就要放宽成Comparable<? super E>。判断方法很简单,去看这个类的定义,如果它是implements Comparable<Animal>而不是implements Comparable<Dog>,就属于后者。用错边界的直接后果是编译报错,但报错信息非常让人摸不着头脑,新手经常在这上面卡一两个小时。
3. 编译器如何“猜”出你的类型:类型推断机制拆解
3.1 目标类型推断:从赋值语句和调用上下文说起
泛型方法最大的便利是大多数时候调用方不用显式写类型参数,编译器能自己推断出来。但这个“推断”到底是怎么发生的?很多人用了很多年也没搞明白,出了问题就只能靠试。
Java 8之后,类型推断是基于目标类型(target typing)的。什么是目标类型?就是编译器从调用上下文里能确定“你需要的是什么类型”的能力。最常见的上下文是赋值语句:
java复制List<String> list = Collections.emptyList();
Collections.emptyList()的完整签名是public static final <T> List<T> emptyList()。这里的T是什么?编译器看到赋值的左值是List<String>,就推断T为String,然后检查List<String>与List<T>在T=String时是否类型兼容,结论是兼容,编译通过。
这个方法调用在Java 7里是需要显式传类型参数的:
java复制List<String> list = Collections.<String>emptyList();
因为Java 7的推断能力很弱,无法从赋值上下文推断泛型方法的类型参数。从Java 8开始,目标类型推断大幅增强,赋值语句、方法调用链、方法引用等场景都能参与推断。Java 9之后又进一步优化,减少了推断失败的概率。
还有一种更精巧的推断场景是链式调用:
java复制List<String> list = new ArrayList<>(Collections.emptyList());
这里Collections.emptyList()的T是通过外层构造函数的参数类型推断出来的。这种情况下如果你不写显式类型参数,编译器会认为T就是外层需要的类型。理解了这种机制,你就能明白为什么在Java 8之前必须加尖括号,而现在不用了——不是语法变了,是编译器变聪明了。
3.2 什么时候推断会失效:显式类型参数的兜底方案
虽然Java 8之后推断能力很强了,但有些场景依然推断不出来。最常见的是下面这个:
java复制Collections.emptyList().forEach(System.out::println);
这里有两个推断:emptyList()要确定T,forEach要遍历元素并把这个元素传给System.out::println。T本身是emptyList方法声明的,编译器需要从后续的forEach调用来推断,而这要求目标类型推断跨方法调用传播。
在实际体验中,这条代码在大多数IDE里能过,但在某些复杂的泛型嵌套场景下会卡壳。比如:
java复制Map<String, List<Integer>> map = new HashMap<>();
map.computeIfAbsent("key", k -> Collections.emptyList());
这段代码编译器会报错,因为Collections.emptyList()在这里推断不出T,lambda表达式k -> Collections.emptyList()的返回类型来自computeIfAbsent的第二个参数——一个Function<? super K, ? extends V>,也就是说返回类型必须是List<Integer>。但编译器在推断lambda体内部的泛型方法时,有时会陷入循环依赖。
兜底方案是显式类型参数:
java复制map.computeIfAbsent("key", k -> Collections.<Integer>emptyList());
这个技巧在各种反射工具、序列化工具中非常重要。我自己在写框架代码时,凡是提供给其他人调用的泛型方法,都会刻意在javadoc里标注“如果编译器推断失败,请显式指定类型参数”。这不是妥协,而是对Java类型系统局限性的尊重。
3.3 泛型方法与通配符:何时用T,何时用?
这是一个被反复问起、也会反复答错的问题。泛型方法使用<T>声明类型变量,而通配符使用?。两者最核心的区别是:?不能用在返回值上,它的重点是表达参数的“边界关系”,而<T>可以把类型变量在参数和返回值之间建立关联。
看这个例子,不考虑参数边界,写出一个“合并两个集合”的方法:
java复制public static <T> List<T> merge(List<? extends T> left, List<? extends T> right)
这里为什么参数用通配符而不直接用List<T>?因为List<? extends T>能接受T的任何子类型,调用灵活性更大。假设你有List<String>和List<Object>,如果方法签名是merge(List<T>, List<T>),当T推断成Object时,List<String>是可以传进List<T>的——问题在于如果你有一个List<CharSequence>和一个List<String>,T推断成Object时两个都能传,但返回类型就变成List<Object>了;如果你想让返回类型是List<CharSequence>,就必须让T推断成CharSequence,这就需要第二个参数的类型是List<? extends CharSequence>而不是List<String>——因为List<String>并不能赋值给List<CharSequence>。
这种细微的差异用语言讲很容易绕晕,我用一个判断口诀帮大家化繁为简:
- 如果类型只出现在参数中,不参与返回值,用
? - 如果类型同时出现在参数和返回值中,用
<T>并在参数上用? extends或? super做边界 - 如果类型只出现在返回值中,必须用
<T>
口诀归口诀,真正理解还是要靠多写。我见过不少开发者在?和T之间反复横跳,最后干脆把参数也写成List<?>然后放任警告。但这会让你丢掉编译器的类型保护,得不偿失。
4. 实战演练:把一个非泛型工具类重构成泛型方法
4.1 第一步:识别需要泛型化的信号
假设你接手了一个老项目,里面有这样一个缓存工具类:
java复制public class CacheUtil {
private static final Map<String, Object> STORE = new HashMap<>();
public static void put(String key, Object value) {
STORE.put(key, value);
}
public static Object get(String key) {
return STORE.get(key);
}
}
典型的非泛型设计。调用方的代码长这样:
java复制User user = (User) CacheUtil.get("user_123");
String name = (String) CacheUtil.get("config_name");
每次get回来都是Object,然后调用方自己强转。强转的坏处我之前说了:编译器不检查,运行期爆炸。更深层的坏处是,这种代码会导致后续的每个调用方都要自己写一次强转,代码重复率极高。
重构的第一步,是写出泛型版本的方法签名:
java复制public static <T> T get(String key) {
return (T) STORE.get(key);
}
不要觉得这样就完事了。上面这个写法藏着问题:它把一个Object强转成T,编译器会给出unchecked警告。这个警告出现得合情合理,因为编译器无法证明STORE里存的确实是你想要的类型。在没有其他约束的情况下,get方法确实没办法在类型层面保证安全——所以这才是真正的核心矛盾。
这个场景在第30条里被提到过,它属于“类型安全的异构容器”(typesafe heterogeneous container)的范畴,但那是第33条的主题。在第30条这个上下文里,我想表达的是:如果当前的设计不允许你使用强类型的关键字区分不同类型,那<T> T get(String key)的强转是可以接受的,但必须在javadoc里明确说明“调用方需要保证key对应的值确实是目标类型”。
4.2 更强的版本:用keys区分类型,把字面类型当成参数
第33条里Joshua Bloch给出的解法是用Class<T>做类型令牌,但我在这儿先不说那么远。我们聚焦在泛型方法这个层面,你会发现一个合理的设计是:
java复制public static <T> T get(String key, Class<T> type) {
Object value = STORE.get(key);
return type.cast(value);
}
注意这里用了Class.cast()而不是直接强转,因为这次编译器能验证强转的安全性——type.cast(value)在运行期确实检查了类型,不匹配会抛出ClassCastException,但不会污染整个JVM的状态,只是在调用点暴露问题。更重要的是,拿到泛型方法配合Class对象,Compiler可以推断T并且序列化器的自动转换也可以在这里做。
这个版本相比之前的<T> T get(String key),在类型安全上有了质的飞跃。调用方直接写:
java复制User user = CacheUtil.get("user_123", User.class);
编译器随即推断T为User,并且type.cast(value)在运行期会校验返回类型真的能强转成User,如果缓存里存的是其他类型,这段代码立刻抛异常,而不是等调用方后续使用的时候才发现。
4.3 用泛型方法统一入口:从三个重载里解放出来
再聊一个企业应用里常见的场景——从前有个接口定义了“保存用户”“保存订单”“保存商品”三个方法,签名分别是:
java复制void saveUser(User user);
void saveOrder(Order order);
void saveProduct(Product product);
三个方法内部逻辑完全一样,都是把对象序列化后写进数据库。这种代码在业务里极其常见,但它确实浪费了泛型方法能带来的简化能力。
泛型化之后:
java复制public <T> void save(T entity) {
// 序列化 + 写库
}
调用方不用改,save(user)和save(order)都能编译通过,内部拿到的T就是对应类型。有人担心这么一做,会不会丢失类型信息,导致序列化的时候不知道该用哪个策略?实际上不会,因为T在运行期被擦除,但序列化框架通常是通过反射获取对象的实际运行时类型来做策略选择的,泛型方法并不影响这一点。
从我挨过打的经验来说,如果三个方法的方法体真的完全一样,只是参数类型不同,那就该泛型化。如果方法体内部要根据具体类型走不同分支,那泛型化就不合适——因为instanceof T这种写法本身就是不可行的,T已经被擦除了,你只能在方法内部用instanceof Object,没有任何意义。
4.4 与函数式接口组合:泛型方法在Stream生态中的应用
Java 8之后,泛型方法与函数式接口的组合是另一大应用场景。函数式接口的抽象方法本身可以声明泛型,这使得我们可以写出灵活的处理管道。
java复制public static <T, R> List<R> map(List<T> source, Function<T, R> mapper) {
List<R> result = new ArrayList<>(source.size());
for (T item : source) {
result.add(mapper.apply(item));
}
return result;
}
调用方在写map(userList, User::getName)时,Function<T, R>的T和R都会被推断出来。这里T和R是泛型方法的两个类型参数,各自独立推断,互不干扰。
这种写法的价值在于,map方法的返回类型List<R>和回调函数Function<T, R>之间建立了类型层面的绑定。如果你写的mapper函数返回Integer,但调用方赋值给List<String>,编译器会在编译期就拦截。这种约束能力是Object版本完全不具备的。
我在用一种更高级的组合模式时,会把泛型方法和策略模式结合,给一套处理流程提供类型安全的路由。比如这样:
java复制public static <T> void process(List<T> data, List<Consumer<T>> handlers)
这个方法遍历数据,每个元素都依次交给所有handler处理。因为类型参数T在方法和handler之间是一致的,调用方可以安全地传入Consumer<String>和List<String>,编译器保证类型匹配。这里的泛型方法起到的作用就像一个“类型管道”,把不同类型的数据流导入到同一套处理逻辑中。
5. 避坑指南:泛型方法常见坑与排查技巧
5.1 擦除效应:别试图重载仅返回类型不同的泛型方法
泛型信息在编译后会被擦除,这是Java泛型实现的核心约束,也是很多坑的根源。最典型的一个坑是试图写这种重载:
java复制public static <T> T getValue(String key) { ... }
public static String getValue(String key) { ... }
这段代码在编译期就报错,因为擦除之后两个方法签名都是getValue(String),编译器认为这是重复定义。而且即使能编译,运行期JVM也无法区分哪个版本是哪个版本。
还有一个更隐蔽的坑,是我在帮同事排查问题时遇到的。他写了两个泛型方法,参数数量不同:
java复制public static <T> void handle(T value) { ... }
public static <T> void handle(List<T> values) { ... }
表面上看参数不同,一个接收T,一个接收Listhandle(null)时,编译器无法判断该调用哪个——因为null可以匹配任何类型。这个编译错误看起来莫名其妙,实际上是两个方法签名在擦除后发生了“模糊匹配”。排查的唯一办法就是显式声明:handle((List<String>) null)。
这类坑的根源都是擦除导致的信息丢失,我的经验是:泛型方法尽量避免重载,哪怕参数类型不同。如果非要重载,确保参数在擦除后依然能明确区分,比如一个接收String,一个接收List
5.2 unchecked警告处理:什么时候能压制,什么时候必须修
泛型方法的强转绕不开unchecked警告。<T> T这种式子本质上都是类型擦除后在玩信任游戏,编译器给你打警告是在提醒你:“这段代码的安全要你用人格担保。”
新手常见的错误是看到警告就直接加@SuppressWarnings("unchecked")压掉。我不是反对压制,问题是压制之前你要想清楚三个问题:
- 这个强转真的安全吗?还是说你只是在赌调用方不会传错类型?
- 如果运行期真的抛了ClassCastException,你能快速定位到这段代码吗?
- 有没有更安全的设计可以绕过强转?
这个思考过程很重要。以第4节里的CacheUtil.get(String key)为例,(T) STORE.get(key)这个强转确实不安全,因为调用方可能传错key。而CacheUtil.get(String key, Class<T> type)用了type.cast(),根本不需要压制警告,编译器就知道这段代码是安全的。
对于真正安全的强转,比如泛型单例工厂里的(UnaryFunction<T>) IDENTITY,压制警告是合理的,但添加注释解释为什么安全是必要的:
java复制@SuppressWarnings("unchecked")
public static <T> UnaryFunction<T> identityFunction() {
// IDENTITY是无状态的,它对所有类型表现一致,
// 所以这里的强转在类型擦除后不会产生运行期风险。
return (UnaryFunction<T>) IDENTITY;
}
这段注释能帮你三个月后再回来看代码时,不需要重新推理一遍安全性。代码评审的时候,我第一个关注的就是@SuppressWarnings出现在哪里,它覆盖的范围有多大。规范的做法是让它精确落在最小作用域——方法上已经是底线,放在类上这种事情我坚决不允许。
5.3 性能真相:泛型方法真的比Object方法慢吗
很多开发者有一个误解,认为泛型方法由于多了类型检查,性能会下降。这个误解完全搞反了。因为类型擦除,泛型方法的字节码和非泛型版本在运行期几乎一致,编译器只是在你调用的地方偷偷插入强转。
看个具体例子:
java复制public static <E extends Comparable<E>> E max(Collection<E> c)
擦除后的字节码等价于:
java复制public static Comparable max(Collection c)
方法内部并没有额外的类型检查,实际调用的时候,编译器会在调用方插入checkcast指令,把返回的Comparable强转成目标类型。这个强转操作和你在代码里手写(String) max(list)没有本质区别,代价微乎其微。
所以性能问题根本不用考虑。真正需要关注的性能隐患是别的地方:比如你在泛型方法内部不小心创建了新的集合对象,比如你给泛型方法传入的参数触发了自动装箱装箱,这些和泛型本身无关。我在性能分析时见过有人把锅甩给泛型,说泛型方法调得慢,最后定位结果是方法内部有数据库查询。这类误判在我接触的团队里不止一次出现,这里就统一说明白:泛型方法的性能特征和非泛型版本本质上没有差别。
5.4 代码评审中常见的泛型方法“坏味道”
代码评审看多了,我总结了几种典型的泛型方法坏味道,你可以在Review时按图索骥。
第一种是“类型参数不参与签名”。如果一个泛型方法声明的类型参数T,既没有出现在参数中,也没有出现在返回值中,只在方法内部用了,那这个方法大概率有设计问题。比如:
java复制public static <T> void printList() {
List<String> data = getData();
data.forEach(System.out::println);
}
这个T毫无意义,纯粹为了加而加。这种代码在Review时必须打回去。
第二种是“泛型边界过度设计”。比如写了个<T extends Comparable<? super T> & Serializable & Cloneable>,看起来非常“高级”,实际上调用方根本找不到能满足所有边界的类型。边界的设计原则是:只约束真正需要的条件。多一个边界就多一层使用门槛。
第三种是混淆类型参数的含义。比如一个方法同时有T和E,但两者在业务上没有区分,本质上都是“集合元素类型”。这种代码可读性很差,建议用有业务含义的命名,比如用USER、ORDER代替T、E,前提是你能确定这个类型参数确实代表这一类东西。
第四种是忽略泛型方法的可推断性。如果你设计的方法在大多数调用场景下都要显式传类型参数,说明类型推断设计得不好,需要重新审视签名。好的泛型方法设计应该让90%的调用都不需要写尖括号。
最后,我在团队内部有一条硬性规定:所有对外暴露的泛型方法,必须在javadoc里说明类型参数的含义、边界条件的含义、以及什么情况下编译器会需要显式类型参数。这样做的好处是,半年后调用方遇到推断失败的场景,翻文档能自助解决,不用再来问设计者。这不仅是规范问题,更是降低团队沟通成本的有效手段。
关于泛型方法的坑,能说的还有很多,比如与varargs的互相影响、在lambda表达式里捕获泛型变量时对final的要求、以及某个类自身需要引用自己的泛型类型参数等,这些后续可以单独再开文章聊。
回到第30条本身,“优先考虑泛型方法”不是我写了多少个泛型方法、用了多少复杂的边界条件,而是在设计方法签名的时候,始终把类型安全放在第一位,让编译器当你的第一道防线。我在Review代码时,只要看到一个方法接收Object参数或者返回Object,就会追问一句“这块儿能不能用泛型写得更精确”。这六个字,其实浓缩了Effective Java整本书的核心追求:让错误在编译期暴露,而不是在运行期爆炸。写代码的时候多想这一步,后面省下的是整个团队排查问题的时间,非常划算。
