Effective Java 第三版——26. 不要使用原始类型

Tips
《Effective Java, Third Edition》一书英文版已经出版，这本书的第二版想必不少人都读过，号称Java四大名著之一，不过第二版2009年出版，到如今已经将近8年的时间，但随着Java 6，7，8，甚至9的发布，Java语言发生了深入的变化。
在这里第一时间翻译成中文版。供你们学习分享之用。

自Java 5以来，泛型已经成为该语言的一部分。 在泛型以前，你必须转换从集合中读取的每一个对象。 若是有人不当心插入了错误类型的对象，则在运行时可能会失败。 使用泛型，你告诉编译器在每一个集合中容许哪些类型的对象。 编译器会自动插入强制转换，并在编译时告诉你是否尝试插入错误类型的对象。 这样作的结果是既安全又清晰的程序，但这些益处，不限于集合，是有代价的。 本章告诉你如何最大限度地提升益处，并将并发症降至最低。

26. 不要使用原始类型

首先，有几个术语。一个类或接口，它的声明有一个或多个类型参数（ type parameters ），被称之为泛型类或泛型接口[JLS，8.1.2,9.1.2]。 例如，List接口具备单个类型参数E，表示其元素类型。 接口的全名是List<E>（读做“E”的列表），可是人们常常称它为List。 泛型类和接口统称为泛型类型（generic types）。

每一个泛型定义了一组参数化类型（parameterized types），它们由类或接口名称组成，后跟一个与泛型类型的形式类型参数[JLS，4.4,4.5]相对应的实际类型参数的尖括号“<>”列表。 例如，List<String>（读做“字符串列表”）是一个参数化类型，表示其元素类型为String的列表。 （String是与形式类型参数E相对应的实际类型参数）。

最后，每一个泛型定义了一个原始类型（ raw type），它是没有任何类型参数的泛型类型的名称[JLS，4.8]。 例如，对应于List<E>的原始类型是List。 原始类型的行为就像全部的泛型类型信息都从类型声明中被清除同样。 它们的存在主要是为了与没有泛型以前的代码相兼容。

在泛型被添加到Java以前，这是一个典型的集合声明。 从Java 9开始，它仍然是合法的，但并非典型的声明方式了：

// Raw collection type - don't do this!

// My stamp collection. Contains only Stamp instances.
private final Collection stamps = ... ;

若是你今天使用这个声明，而后不当心把coin实例放入你的stamp集合中，错误的插入编译和运行没有错误（尽管编译器发出一个模糊的警告）：

// Erroneous insertion of coin into stamp collection
stamps.add(new Coin( ... )); // Emits "unchecked call" warning

直到您尝试从stamp集合中检索coin实例时才会发生错误：

// Raw iterator type - don't do this!
for (Iterator i = stamps.iterator(); i.hasNext(); )
    Stamp stamp = (Stamp) i.next(); // Throws ClassCastException
        stamp.cancel();

正如本书所提到的，在编译完成以后尽快发现错误是值得的，理想状况是在编译时。 在这种状况下，直到运行时才发现错误，在错误发生后的很长一段时间，以及可能远离包含错误的代码的代码中。 一旦看到ClassCastException，就必须搜索代码类库，查找将coin实例放入stamp集合的方法调用。 编译器不能帮助你，由于它不能理解那个说“仅包含stamp实例”的注释。

对于泛型，类型声明包含的信息，而不是注释：

// Parameterized collection type - typesafe
private final Collection<Stamp> stamps = ... ;

从这个声明中，编译器知道stamps集合应该只包含Stamp实例，并保证它是true，假设你的整个代码类库编译时不发出（或者抑制;参见条目27）任何警告。 当使用参数化类型声明声明stamps时，错误的插入会生成一个编译时错误消息，告诉你到底发生了什么错误：

Test.java:9: error: incompatible types: Coin cannot be converted
to Stamp
    c.add(new Coin());
              ^

当从集合中检索元素时，编译器会为你插入不可见的强制转换，并保证它们不会失败（再假设你的全部代码都不会生成或禁止任何编译器警告）。 虽然意外地将coin实例插入stamp集合的预期可能看起来很牵强，但这个问题是真实的。 例如，很容易想象将BigInteger放入一个只包含BigDecimal实例的集合中。

如前所述，使用原始类型（没有类型参数的泛型）是合法的，可是你不该该这样作。 若是你使用原始类型，则会丧失泛型的全部安全性和表达上的优点。 鉴于你不该该使用它们，为何语言设计者首先容许原始类型呢？ 答案是为了兼容性。 泛型被添加时，Java即将进入第二个十年，而且有大量的代码没有使用泛型。 全部这些代码都是合法的，而且与使用泛型的新代码进行交互操做被认为是相当重要的。 将参数化类型的实例传递给为原始类型设计的方法必须是合法的，反之亦然。 这个需求，被称为迁移兼容性，驱使决策支持原始类型，并使用擦除来实现泛型（条目 28）。

虽然不该使用诸如List之类的原始类型，但可使用参数化类型来容许插入任意对象（如List<Object>）。 原始类型List和参数化类型List<Object>之间有什么区别？ 松散地说，前者已经选择了泛型类型系统，然后者明确地告诉编译器，它可以保存任何类型的对象。 虽然能够将List<String>传递给List类型的参数，但不能将其传递给List<Object>类型的参数。 泛型有子类型的规则，List<String>是原始类型List的子类型，但不是参数化类型List<Object>的子类型（条目 28）。 所以，若是使用诸如List之类的原始类型，则会丢失类型安全性，可是若是使用参数化类型（例如List <Object>）则不会。

为了具体说明，请考虑如下程序：

// Fails at runtime - unsafeAdd method uses a raw type (List)!
public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    unsafeAdd(strings, Integer.valueOf(42));
    String s = strings.get(0); // Has compiler-generated cast
}

private static void unsafeAdd(List list, Object o) {
    list.add(o);
}

此程序能够编译，它使用原始类型列表，但会收到警告：

Test.java:10: warning: [unchecked] unchecked call to add(E) as a
member of the raw type List
    list.add(o);
            ^

实际上，若是运行该程序，则当程序尝试调用strings.get(0)的结果（一个Integer）转换为一个String时，会获得ClassCastException异常。 这是一个编译器生成的强制转换，所以一般会保证成功，但在这种状况下，咱们忽略了编译器警告并付出了代价。

若是用unsafeAdd声明中的参数化类型List <Object>替换原始类型List，并尝试从新编译该程序，则会发现它再也不编译，而是发出错误消息：

Test.java:5: error: incompatible types: List<String> cannot be
converted to List<Object>
    unsafeAdd(strings, Integer.valueOf(42));

你可能会试图使用原始类型来处理元素类型未知且可有可无的集合。 例如，假设你想编写一个方法，它须要两个集合并返回它们共同拥有的元素的数量。 若是是泛型新手，那么您能够这样写：

// Use of raw type for unknown element type - don't do this!
static int numElementsInCommon(Set s1, Set s2) {
    int result = 0;
    for (Object o1 : s1)
        if (s2.contains(o1))
            result++;
    return result;
}

这种方法能够工做，但它使用原始类型，这是危险的。 安全替代方式是使用无限制通配符类型（unbounded wildcard types）。 若是要使用泛型类型，但不知道或关心实际类型参数是什么，则可使用问号来代替。 例如，泛型类型Set<E>的无限制通配符类型是Set <?>（读取“某种类型的集合”）。 它是最通用的参数化的Set类型，可以保持任何集合。 下面是numElementsInCommon方法使用无限制通配符类型声明的状况：

// Uses unbounded wildcard type - typesafe and flexible
static int numElementsInCommon(Set<?> s1, Set<?> s2) { ... }

无限制通配符Set <?>与原始类型Set之间有什么区别？ 问号真的给你听任何东西吗？ 这不是要点，但通配符类型是安全的，原始类型不是。 你能够将任何元素放入具备原始类型的集合中，轻易破坏集合的类型不变性（如第119页上的unsafeAdd方法所示）; 你不能把任何元素（除null以外）放入一个Collection <?>中。 试图这样作会产生一个像这样的编译时错误消息：

WildCard.java:13: error: incompatible types: String cannot be
converted to CAP#1
    c.add("verboten");
          ^
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Object from capture of ?

不能否认的是，这个错误信息留下了一些须要的东西，可是编译器已经完成了它的工做，无论它的元素类型是什么，都不会破坏集合的类型不变性。 你不只能够将任何元素（除null之外）放入一个Collection <?>中，可是不能保证你所获得的对象的类型。 若是这些限制是不可接受的，可使用泛型方法（条目 30）或有限制配符类型（条目 31）。

对于不该该使用原始类型的规则，有一些小例外。 你必须在类字面值（class literals）中使用原始类型。 规范中不容许使用参数化类型（尽管它容许数组类型和基本类型）[JLS，15.8.2]。 换句话说，List.class，String [] .class和int.class都是合法的，但List <String> .class和List <?>.class不是合法的。

规则的第二个例外涉及instanceof操做符。 由于泛型类型信息在运行时被删除，因此在无限制通配符类型之外的参数化类型上使用instanceof运算符是非法的。 使用无限制通配符类型代替原始类型不会以任何方式影响instanceof运算符的行为。 在这种状况下，尖括号和问号就显得多余。 如下是使用泛型类型的instanceof运算符的首选方法：

// Legitimate use of raw type - instanceof operator
if (o instanceof Set) {       // Raw type
    Set<?> s = (Set<?>) o;    // Wildcard type
    ...
}

请注意，一旦肯定o对象是一个Set，则必须将其转换为通配符Set <?>，而不是原始类型Set。 这是一个强制转换，因此不会致使编译器警告。

总之，使用原始类型可能致使运行时异常，因此不要使用它们。 它们仅用于与泛型引入以前的传统代码的兼容性和互操做性。 做为一个快速回顾，Set<Object>是一个参数化类型，表示一个能够包含任何类型对象的集合，Set<?>是一个通配符类型，表示一个只能包含某些未知类型对象的集合，Set是一个原始类型，它不在泛型类型系统之列。 前两个类型是安全的，最后一个不是。

为了快速参考，下表中总结了本条目（以及本章稍后介绍的一些）中介绍的术语：

术语	中文含义	举例	所在条目
Parameterized type	参数化类型	List<String>	条目 26
Actual type parameter	实际类型参数	String	条目 26
Generic type	泛型类型	List<E>	条目 26
Formal type parameter	形式类型参数	E	条目 26
Unbounded wildcard type	无限制通配符类型	List<?>	条目 26
Raw type	原始类型	List	条目 26
Bounded type parameter	限制类型参数	<E extends Number>	条目 29
Recursive type bound	递归类型限制	<T extends Comparable<T>>	条目 30
Bounded wildcard type	限制通配符类型	List<? extends Number>	条目 31
Generic method	泛型方法	static <E> List<E> asList(E[] a)	条目 30
Type token	类型令牌	String.class	条目 33