跳到主要内容
约 11 分钟5 张卡

Java 泛型

泛型让类、接口和方法带上类型参数,同一份代码可以用于不同类型,同时保留编译期的类型检查。比如 List<String> 会在编译期拒绝写入整数,读取时也不用手写强制转换。

理解泛型,要把编译期的约束和运行时的检查分开。类型参数和通配符决定哪些操作能通过编译,类型擦除则解释了为什么有些类型信息不会留到运行时,以及绕过编译检查后,错误会在哪里暴露。

1. 面试核心​

先记住这几条,再读正文
  • 泛型用同一个类型参数关联字段、入参和返回值,让编译器检查这些类型关系。集合、容器和通用接口因此能复用代码,调用方也少写强制转换。卡 · 类型参数
  • 泛型是不变的:Integer 是 Number 的子类型,List<Integer> 却不能赋给 List<Number>,否则整数列表就可能被写入 Double。
  • ? extends T 适合按 T 读取,? super T 适合写入 T 及其子类型的值。记作 PECS:提供数据用 extends,接收数据用 super。卡 · 通配符
  • 编译器先检查泛型,再擦除:类型变量替换成上界,需要的地方插入强制转换。通过原始类型或反射把错误元素写入集合后,异常可能到按声明类型读取时才暴露。卡 · 类型擦除
  • 擦除后,接口方法和实现方法的签名可能对不上,编译器生成桥接方法来转换参数、转发调用,维持重写关系。卡 · 桥接方法与运行时类型检查
  • 泛型变长参数的数组检查不到具体的类型参数,错误类型可能混进去;@SafeVarargs 只是作者的安全声明,不会修复不安全的实现。卡 · 泛型变长参数与堆污染

2. 类型参数​

类型参数是留给使用方来确定的类型,比如 T。泛型类用同一个类型参数把字段、构造参数和返回值关联起来,同一个结构就能装不同类型的值:

final class Box<T> {
private final T value;

Box(T value) {
this.value = value;
}

T get() {
return value;
}
}

Box<String> box = new Box<>("java");
String value = box.get();

创建 Box<String> 后,构造参数和 get() 的返回值都按 String 检查。传入整数会编译失败,取值时也能直接赋给 String,不用手写强制转换。

泛型方法则把自己的类型参数声明在返回类型之前:

static <T> List<T> wrap(T value) {
return List.of(value);
}

调用 wrap("java") 并用 List<String> 接收时,编译器把 T 推断为 String;传入整数并用 List<Integer> 接收时,T 就是 Integer。参数和接收结果的目标类型一起参与推断,同一个 T 保证了输入和输出的类型一致。如果两边的类型本来就是固定的,直接写具体类型或接口就行。

2.1 类型上界​

类型上界限制类型参数必须是某个类型或它的子类型,也告诉编译器在方法里可以调用哪些方法。比如要对参数调用 Number.doubleValue(),就把上界设为 Number:

static <T extends Number> double twice(T value) {
return value.doubleValue() * 2;
}

T extends Number 表示 T 是 Number 或它的子类型,所以方法里可以调用 doubleValue()。上界可以有多个,用 & 连接,类型必须同时满足全部要求;其中如果有类,类必须写在第一个,后面再列接口。

3. 泛型的不变性​

不变性是指,即使 Integer 是 Number 的子类型,List<Integer> 也不是 List<Number> 的子类型,类型参数之间的关系不会传给泛型类型。下面的赋值会编译失败:

List<Integer> integers = new ArrayList<>(List.of(1, 2));
// List<Number> numbers = integers; // 编译错误

为什么要拒绝?假设这次赋值能通过,numbers 和 integers 就指向同一个列表,numbers.add(3.14) 会把一个 Double 写进这个本该只放 Integer 的列表,之后从 integers 读出的元素就不一定是整数了。所以 Java 在编译期就拒绝这次赋值。

这里特意用可变的 ArrayList,好单独讨论类型约束。List.of 返回的列表本身就不允许修改,那是集合自己的规则,和泛型的类型检查是两回事。

数组的规则相反,它是协变的:Integer[] 可以赋给 Number[]。数组在运行时记得自己的实际元素类型,所以通过 Number[] 写入 Double 时,会在运行时抛出 ArrayStoreException。泛型选择不变性,是把这类错误提前到编译期发现。

4. 通配符​

不变性带来一个麻烦:一个求和方法如果只接受 List<Number>,就没法传 List<Integer> 进去。通配符 ? 用来解决这个问题,它表示「某个未知的类型」。给它加上界或下界,编译器就能推出哪些读写操作是安全的。

4.1 上界通配符​

只需要读取数字时,可以接受元素为 Number 或其子类型的列表。上界通配符用 ? extends Number 表达这个范围:

static double sum(List<? extends Number> values) {
double total = 0;
for (Number value : values) {
total += value.doubleValue();
}
return total;
}

实参可以是 List<Integer>,也可以是 List<Double>。不管是哪一种,读出来的非空元素都能当作 Number 用,所以可以调用 doubleValue()。

写入就不行了。编译器只知道元素是 Number 的某个子类型,不知道具体是哪个:实际传进来的可能是 List<Double>,这时写入 Integer 就破坏了它的约定。所以通过 ? extends Number 的引用直接添加值时,只有 null 能通过类型检查;列表本身接不接受 null,还要看它的实现。

4.2 下界通配符​

方法需要把整数写入列表时,可以用 ? super Integer 接受元素类型为 Integer 或其父类型的列表:

static void addDefaults(List<? super Integer> target) {
target.add(0);
target.add(1);
}

实参可以是 List<Integer>、List<Number> 或 List<Object>,三者都能装下整数 0 和 1,所以写入是安全的。读取时情况反过来:实际的列表可能是 List<Object>,里面可能有任何对象,读出来只能当作 Object 用。

这两种限制可以用 PECS 记忆,即 Producer Extends, Consumer Super:

  • 参数主要提供 T,也就是供方法读取时,使用 extends。
  • 参数主要接收 T,也就是供方法写入时,使用 super。
  • 如果要按同一个具体类型读写,则直接使用 List<T>。

4.3 未知类型与 Object 元素类型​

List<?> 表示元素类型未知,List<Object> 则明确表示元素类型为 Object。前者允许接收各种列表,后者允许写入各种对象,二者不能混用。

List<?> 可以接收 List<String> 等任意元素类型的列表。因为不知道具体类型,读出来只能当 Object 用,直接添加值时类型检查只接受 null,具体列表也仍然可以拒绝 null。

List<Object> 可以写入各种对象,但按照不变性,List<String> 不能赋给它。

5. 类型擦除​

类型擦除是指编译器检查完泛型之后,把类型变量替换成它的第一个上界,没有上界就替换成 Object,这样不同类型参数的泛型代码在运行时共用同一份实现。比如 T extends Number 擦除为 Number,没有上界的 T 擦除为 Object。在需要具体类型的位置,比如把 get() 的结果赋给 String 变量时,编译器会插入强制转换。

因为检查先于擦除,下面的错误在编译期就会被发现:

List<Integer> numbers = new ArrayList<>();
// numbers.add("wrong"); // 编译错误

擦除后,参数化类型 List<String> 和 List<Integer> 都变成 List,不会分别生成两套运行时类型。以 ArrayList 为例,写入时不会再按变量声明检查元素是不是 Integer;绕过编译期检查,就可能把错误类型的值写进去。下面两种写法会削弱这层检查:

  • 原始类型省略了类型参数,例如直接声明 List。
  • 未检查转换是编译器无法确认泛型参数是否匹配的转换,会产生 unchecked 警告。

堆污染是泛型变量所指向的数据与声明的类型约束不一致的状态。原始类型、未检查转换和反射都可能造成这种问题。比如字符串混进整数列表,写入时没有报错,之后按 Integer 读取它时,编译器插入的强制转换才会抛出 ClassCastException。报错位置因此可能离错误写入的位置很远。

擦除还带来四项限制:

  • new T() 无法编译,因为运行时缺少具体类型和构造器信息。创建实例需要显式提供工厂或构造器。
  • new T[] 会编译失败,数组需保留运行时元素类型。
  • Object 无法用 instanceof List<String> 检查元素类型。
  • 参数分别为 List<String> 和 List<Integer> 的两个方法擦除后签名相同,不能形成重载。

擦除还会影响方法重写:源码里构成重写的两个方法,擦除后签名可能不一样了,这由下一节的桥接方法解决。

6. 桥接方法与运行时类型检查​

桥接方法是编译器自动生成的方法,用来补上擦除造成的签名差异,让通过接口发起的调用仍能到达具体实现。看下面的例子:

interface Sink<T> { void accept(T value); }
final class TextSink implements Sink<String> {
public void accept(String value) {}
}

接口的 accept(T) 擦除后变成 accept(Object),而 TextSink 里只有 accept(String),两者签名不同,在 JVM 看来并不构成重写。于是编译器在 TextSink 中生成一个 accept(Object) 作为桥接方法:它先把参数转换成 String,再转发给 accept(String)。

如果通过原始类型传入别的对象,调用会先到达桥接方法,在参数转换这一步抛出 ClassCastException。

擦除之后,运行时还能做多少类型检查,要看表达式已有的静态类型。从 Java 16 开始(Java 17、21 同样支持),instanceof 可以使用部分参数化类型,前提是这次检查不涉及未检查转换:

List<String> values = new ArrayList<>();
System.out.println(values instanceof ArrayList<String>); // true,Java 16+
Object unknown = values;
// boolean valid = unknown instanceof List<String>; // 编译错误
boolean list = unknown instanceof List<?>; // 合法

这三个检查的区别在于编译器已经知道多少类型信息:

  • values 已声明为 List<String>,第一个检查只需判断实现类是否为 ArrayList。
  • unknown 只声明为 Object,无法证明其中所有元素都是 String,所以第二个检查编译失败。
  • List<?> 把元素类型保留为未知,第三个检查只确认对象是否实现 List,因此合法。

7. 泛型变长参数与堆污染​

泛型变长参数同时碰上了数组协变和类型擦除。List<String>... 实际是用数组传递的,擦除后数组的运行时类型是 List[]:它能检查写入的对象是不是列表,却查不出列表里装的是字符串还是整数。下面这个反例因此在读取时才失败:

static String broken(List<String>... values) { // 未检查警告
Object[] aliases = values;
aliases[0] = List.of(42); // 运行时数组类型允许 List
return values[0].get(0); // ClassCastException
}

aliases 和 values 指向同一个数组。写入 List<Integer> 时,数组检查只看到 List,因此允许写入。随后 values[0].get(0) 按声明类型读取 String,实际拿到的却是 Integer,于是转换失败。

@SafeVarargs 是方法作者对类型安全的声明,作用只是抑制对应的未检查警告,不会增加任何运行时检查。加它之前要确认,方法既不往这个数组里写入错误类型,也不把数组暴露给其他可能不安全的代码。

Java 17 和 21 中,这个注解只能用在不会被重写的方法和构造器上:

  • 变长参数构造器。
  • 静态变长参数方法。
  • final 或私有的变长参数实例方法。

其中,私有实例方法从 Java 9 起可以使用 @SafeVarargs。

8. 常见问题​

8.1 为什么不能向 List<? extends Number> 写入 Integer?​

因为实际传入的列表可能是 List<Double>。编译器只知道元素是 Number 的某个子类型,无法确认 Integer 符合这个列表的具体类型。需要写入整数时,改用 List<? super Integer>。

8.2 泛型擦除后,为什么还能通过反射读取部分泛型信息?​

8.3 什么时候直接使用具体类型更合适?​

9. 面试题卡片​

10. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明