自从
泛型被添加到 JDK 5 语言以来,它一直都是一个颇具争议的话题。一部分人认为泛型简化了编程,扩展了类型系统从而使编译器能够检验类型安全;另外一些人认为泛型添加了很多不必要的复杂性。对于泛型我们都经历过一些痛苦的回忆,但毫无疑问
通配符是最棘手的部分。
通配符基本介绍
泛型是一种表示类或方法行为对于未知类型的类型约束的方法,比如 “不管这个方法的参数 x 和 y 是哪种类型,它们必须是相同的类型”,“必须为这些方法提供同一类型的参数” 或者 “foo() 的返回值和 bar() 的参数是同一类型的”。
通配符 — 使用一个奇怪的问号表示类型参数 — 是一种表示未知类型的类型约束的方法。通配符并不包含在最初的泛型设计中(起源于 Generic Java(GJ)项目),从形成
JSR 14 到发布其最终
版本之间的五年多时间内完成设计过程并被添加到了泛型中。
通配符在类型系统中具有重要的
意义,它们为一个泛型类所指定的类型集合提供了一个有用的类型范围。对泛型类 ArrayList 而言,对于任意(引用)类型 T,ArrayList<?> 类型是 ArrayList<T> 的超类型(类似原始类型 ArrayList 和根类型 Object,但是这些超类型在执行类型推断方面不是很有用)。
通配符类型 List<?> 与原始类型 List 和具体类型 List<Object> 都不相同。如果说变量 x 具有 List<?> 类型,这表示存在一些 T 类型,其中 x 是 List<T>类型,x 具有相同的结构,尽管我们不知道其元素的具体类型。这并不表示它可以具有任意内容,而是指我们并不了解内容的类型
限制是什么 — 但我们知道存在 某种限制。另一方面,原始类型 List 是异构的,我们不能对其元素有任何类型限制,具体类型 List<Object> 表示我们明确地知道它能包含任何对象(当然,泛型的类型系统没有 “列表内容” 的概念,但可以从 List 之类的
集合类型轻松地
理解泛型)。
通配符在类型系统中的作用部分来自其不会发生协变(covariant)这一特性。数组是协变的,因为 Integer 是 Number 的子类型,数组类型 Integer[] 是 Number[] 的子类型,因此在任何需要 Number[] 值的地方都可以提供一个 Integer[] 值。另一方面,泛型不是协变的, List<Integer> 不是 List<Number> 的子类型,试图在要求 List<Number> 的位置提供 List<Integer> 是一个类型
错误。这不算很严重的问题 — 也不是所有人都认为的错误 — 但泛型和数组的不同行为的确引起了许多混乱。
我已使用了一个通配符 — 接下来呢?
清单 1 展示了一个简单的容器(container)类型 Box,它支持 put 和 get 操作。 Box 由类型参数 T 参数化,该参数表示 Box 内容的类型, Box<String> 只能包含 String 类型的元素。
清单 1. 简单的泛型 Box 类型
public interface Box<T> {
public T get();
public void put(T element);
}
通配符的一个好处是允许编写可以操作泛型类型变量的代码,并且不需要了解其具体类型。例如,假设有一个 Box<?> 类型的变量,比如清单 2 unbox() 方法中的 box 参数。unbox() 如
何处理已传递的 box?
清单 2. 带有通配符参数的 Unbox 方法
public void unbox(Box<?> box) {
System.out.println(box.get());
}
事实证明 Unbox 方法能做许多工作:它能调用 get() 方法,并且能调用任何从 Object 继承而来的方法(比如
hashCode())。它惟一不能做的事是调用 put() 方法,这是因为在不知道该 Box 实例的类型参数 T 的情况下它不能检验这个操作的
安全性。由于 box 是一个 Box<?> 而不是一个原始的 Box,编译器知道存在一些 T 充当 box 的类型参数,但由于不知道 T 具体是什么,您不能调用 put() 因为不能检验这么做不会违反 Box 的类型安全限制(实际上,您可以在一个特殊的情况下调用 put():当您传递 null 字母时。我们可能不知道 T 类型代表什么,但我们知道 null 字母对任何引用类型而言是一个空值)。
关于 box.get() 的返回类型,unbox() 了解哪些内容呢?它知道 box.get() 是某些未知 T 的 T,因此它可以推断出 get() 的返回类型是 T 的擦除(erasure),对于一个无上限的通配符就是 Object。因此清单 2 中的
表达式 box.get() 具有 Object 类型。
通配符捕获
清单 3 展示了一些似乎应该 可以工作的代码,但实际上不能。它包含一个泛型 Box、提取它的值并试图将值放回同一个 Box。
清单 3. 一旦将值从 box 中取出,则不能将其放回
public void rebox(Box<?> box) {
box.put(box.get());
}
Rebox.java:8: put(capture#337 of ?) in Box<capture#337 of ?>
cannot be applied
to (java.lang.Object)
box.put(box.get());
^
1 error
这个代码看起来应该可以工作,因为取出值的类型符合放回值的类型,然而,编译器生成(令人困惑的)关于 “capture#337 of ?” 与 Object 不兼容的错误消息。
“capture#337 of ?” 表示什么?当编译器遇到一个在其类型中带有通配符的变量,比如 rebox() 的 box 参数,它认识到必然有一些 T ,对这些 T 而言 box 是 Box<T>。它不知道 T 代表什么类型,但它可以为该类型创建一个占位符来指代 T 的类型。占位符被称为这个特殊通配符的捕获(capture)。这种情况下,编译器将名称 “capture#337 of ?” 以 box 类型分配给通配符。每个变量声明中每出现一个通配符都将获得一个不同的捕获,因此在泛型声明 foo(Pair<?,?> x, Pair<?,?> y) 中,编译器将给每四个通配符的捕获分配一个不同的名称,因为任意未知的类型参数之间没有关系。
错误消息告诉我们不能调用 put(),因为它不能检验 put() 的实参类型与其形参类型是否兼容 — 因为形参的类型是未知的。 在这种情况下,由于 ? 实际表示 “?extends Object” ,编译器已经推断出 box.get() 的类型是 Object,而不是 “capture#337 of ?”。它不能静态地检验对由占位符 “capture#337 of ?” 所识别的类型而言 Object 是否是一个可接受的值。
捕获助手
虽然编译器似乎丢弃了一些有用的信息,我们可以使用一个技巧来使编译器重构这些信息,即对未知的通配符类型命名。清单 4 展示了 rebox() 的实现和一个实现这种技巧的泛型助手方法(helper):
清单 4. “捕获助手” 方法
public void rebox(Box<?> box) {
reboxHelper(box);
}
private<V> void reboxHelper(Box<V> box) {
box.put(box.get());
}
助手方法 reboxHelper() 是一个泛型方法, 泛型方法引入了额外的类型参数(位于返回类型之前的尖括号中),这些参数用于表示参数和/或方法的返回值之间的类型约束。然而就 reboxHelper() 来说,泛型方法并不使用类型参数指定类型约束,它允许编译器(通过类型
接口)对 box 类型的类型参数命名。
捕获助手技巧允许我们在处理通配符时绕开编译器的限制。当 rebox() 调用 reboxHelper() 时,它知道这么做是安全的,因为它自身的 box 参数对一些未知的 T 而言一定是 Box<T>。因为类型参数 V 被引入到方法签名中并且没有绑定到其他任何类型参数,它也可以表示任何未知类型,因此,某些未知 T 的 Box<T> 也可能是某些未知 V 的 Box<V>(这和 lambda 积分中的 α
减法原则相似,允许重命名边界变量)。现在 reboxHelper() 中的表达式 box.get() 不再具有 Object 类型,它具有 V 类型 — 并允许将 V 传递给 Box<V>.put()。
我们本来可以将 rebox() 声明为一个泛型方法,类似 reboxHelper(),但这被认为是一种糟糕的 API 设计样式。此处的主要设计原则是 “如果以后
绝不会按名称引用,则不要进行命名”。就泛型方法来说,如果一个类型参数在方法签名中只出现一次,它很有可能是一个通配符而不是一个命名的类型参数。一般来说,带有通配符的 API 比带有泛型方法的 API 更简单,在更复杂的方法声明中类型名称的增多会降低声明的可读性。因为在需要时始终可以通过专有的捕获助手恢复名称,这个方法让您能够保持 API 整洁,同时不会删除有用的信息。
类型推断
捕获助手技巧涉及多个因素:类型推断和捕获转换。Java 编译器在很多情况下都不能执行类型推断,但是可以为泛型方法推断类型参数(其他语言更加依赖类型推断,将来我们可以看到 Java 语言中会添加更多的类型推断特性)。如果愿意,您可以指定类型参数的值,但只有当您能够命名该类型时才可以这样做 — 并且不能够表示捕获类型。因此要使用这种技巧,要求编译器能够为您推断类型。捕获转换允许编译器为已捕获的通配符产生一个占位符类型名,以便对它进行类型推断。
当
解析一个泛型方法的调用时,编译器将设法推断类型参数它能达到的最具体类型。 例如,对于下面这个泛型方法:
public static<T> T identity(T arg) { return arg };
和它的调用:
Integer i = 3;
System.out.println(identity(i));
编译器能够推断 T 是 Integer、Number、 Serializable 或 Object,但它选择 Integer 作为满足约束的最具体类型。
当构造泛型实例时,可以使用类型推断减少冗余。例如,使用 Box 类创建 Box<String> 要求您指定两次类型参数 String:
Box<String> box = new BoxImpl<String>();
即使可以使用 IDE 执行一些工作,也不要违背 DRY(Don't Repeat Yourself)原则。然而,如果实现类 BoxImpl 提供一个类似清单 5 的泛型工厂方法(这始终是个好主意),则可以减少客户机代码的冗余:
清单 5. 一个泛型工厂方法,可以避免不必要地指定类型参数
public
class BoxImpl<T> implements Box<T> {
public static<V> Box<V> make() {
return new BoxImpl<V>();
}
...
}
如果使用 BoxImpl.make() 工厂实例化一个 Box,您只需要指定一次类型参数:
Box<String> myBox = BoxImpl.make();
泛型 make() 方法为一些类型 V 返回一个 Box<V>,返回值被用于需要 Box<String> 的上下文中。编译器确定 String 是 V 能接受的满足类型约束的最具体类型,因此此处将 V 推断为 String。您还可以手动地指定 V 的值:
Box<String> myBox = BoxImpl.<String>make();
除了减少一些键盘操作以外,此处演示的工厂方法技巧还提供了优于
构造函数的其他优势:您能够为它们提高更具描述性的名称,它们能够返回命名返回类型的子类型,它们不需要为每次调用创建新的实例,从而能够共享不可变的实例(参见 参考资料 中的 Effective Java, Item #1,了解有关静态工厂的更多优点)。
结束语
通配符无疑非常复杂:由 Java 编译器产生的一些令人困惑的错误消息都与通配符有关,Java 语言规范中最复杂的部分也与通配符有关。然而如果使用适当,通配符可以提供强大的功能。此处列举的两个技巧 — 捕获助手技巧和泛型工厂技巧 — 都利用了泛型方法和类型推断,如果使用恰当,它们能显著降低复杂性。