Java泛型总结

jopen 6年前

1. 什么是泛型?

泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。

可以在集合框架(Collection framework)中看到泛型的动机。例如,Map 类允许您向一个 Map 添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String)的对象。

因为 Map.get() 被定义为返回 Object,所以一般必须将 Map.get() 的结果强制类型转换为期望的类型,如下面的代码所示:

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

要让程序通过编译,必须将 get() 的结果强制类型转换为 String,并且希望结果真的是一个 String。但是有可能某人已经在该映射中保存了不是 String 的东西,这样的话,上面的代码将会抛出 ClassCastException。

理想情况下,您可能会得出这样一个观点,即 m 是一个 Map,它将 String 键映射到 String 值。这可以让您消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。

2. 泛型的好处

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化,以支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。这带来了很多好处:

类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。

Java 程序中的一种流行技术是定义这样的集合,即它的元素或键是公共类型的,比如 “String 列表”或者“String 到 String 的映射”。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了,而不是在运行时当作 ClassCastException 展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性。

消除强制类型转换。 泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。

尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度,但是声明泛型变量会带来相应的罗嗦。比较下面两个代码例子。

该代码不使用泛型:

List li = new ArrayList();

li.put(new Integer(3));

Integer i = (Integer) li.get(0);

该代码使用泛型:

List<Integer> li = new ArrayList<Integer>();

li.put(new Integer(3));

Integer i = li.get(0);

在简单的程序中使用一次泛型变量不会降低罗嗦程度。但是对于多次使用泛型变量的大型程序来说,则可以累积起来降低罗嗦程度。

潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(没有泛型的话,程序员会指定这些强制类型转换)插入生成的字节码中。但是更多类型信息可用于编译器这一事实,为未来版本的 JVM 的优化带来可能。

由于泛型的实现方式,支持泛型(几乎)不需要 JVM 或类文件更改。所有工作都在编译器中完成,编译器生成类似于没有泛型(和强制类型转换)时所写的代码,只是更能确保类型安全而已。

3. 泛型用法的例子

泛型的许多最佳例子都来自集合框架,因为泛型让您在保存在集合中的元素上指定类型约束。考虑这个使用 Map 类的例子,其中涉及一定程度的优化,即 Map.get() 返回的结果将确实是一个 String:

Map m = new HashMap();

m.put("key", "blarg");

String s = (String) m.get("key");

如果有人已经在映射中放置了不是 String 的其他东西,上面的代码将会抛出 ClassCastException。泛型允许您表达这样的类型约束,即 m 是一个将 String 键映射到 String 值的 Map。这可以消除代码中的强制类型转换,同时获得一个附加的类型检查层,这个检查层可以防止有人将错误类型的键或值保存在集合中。

下面的代码示例展示了 JDK 5.0 中集合框架中的 Map 接口的定义的一部分:

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

注意该接口的两个附加物:

类型参数 K 和 V 在类级别的规格说明,表示在声明一个 Map 类型的变量时指定的类型的占位符。

在 get()、put() 和其他方法的方法签名中使用的 K 和 V。

为了赢得使用泛型的好处,必须在定义或实例化 Map 类型的变量时为 K 和 V 提供具体的值。以一种相对直观的方式做这件事:

Map<String, String> m = new HashMap<String, String>();

m.put("key", "blarg");

String s = m.get("key");

当使用 Map 的泛型化版本时,您不再需要将 Map.get() 的结果强制类型转换为 String,因为编译器知道 get() 将返回一个 String。

在使用泛型的版本中并没有减少键盘录入;实际上,比使用强制类型转换的版本需要做更多键入。使用泛型只是带来了附加的类型安全。因为编译器知道关于您将放进 Map 中的键和值的类型的更多信息,所以类型检查从执行时挪到了编译时,这会提高可靠性并加快开发速度。

向后兼容

在 Java 语言中引入泛型的一个重要目标就是维护向后兼容。尽管 JDK 5.0 的标准类库中的许多类,比如集合框架,都已经泛型化了,但是使用集合类(比如 HashMap 和 ArrayList)的现有代码将继续不加修改地在 JDK 5.0 中工作。当然,没有利用泛型的现有代码将不会赢得泛型的类型安全好处。

4. 泛型基础

4.1 类型参数

在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。形式类型参数与实际类型参数之间的关系类似于形式方法参数与实际方法参数之间的关系,只是类型参数表示类型,而不是表示值。

泛型类中的类型参数几乎可以用于任何可以使用类名的地方。例如,下面是 java.util.Map 接口的定义的摘录:

public interface Map<K, V> {

public void put(K key, V value);

public V get(K key);

}

Map 接口是由两个类型参数化的,这两个类型是键类型 K 和值类型 V。(不使用泛型)将会接受或返回 Object 的方法现在在它们的方法签名中使用 K 或 V,指示附加的类型约束位于 Map 的规格说明之下。

当声明或者实例化一个泛型的对象时,必须指定类型参数的值:

Map<String, String> map = new HashMap<String, String>();

注意,在本例中,必须指定两次类型参数。一次是在声明变量 map 的类型时,另一次是在选择 HashMap 类的参数化以便可以实例化正确类型的一个实例时。

编译器在遇到一个 Map<String, String> 类型的变量时,知道 K 和 V 现在被绑定为 String,因此它知道在这样的变量上调用 Map.get() 将会得到 String 类型。

除了异常类型、枚举或匿名内部类以外,任何类都可以具有类型参数。

4.2 命名类型参数

推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同(参阅 附录 A:与 C++ 模板的比较),并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式,推荐的名称是:

K —— 键,比如映射的键。

V —— 值,比如 List 和 Set 的内容,或者 Map 中的值。

E —— 异常类。

T —— 泛型。

4.3 泛型不是协变的

关于泛型的混淆,一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。List<Object> 不是 List<String> 的父类型。

如果 A 扩展 B,那么 A 的数组也是 B 的数组,并且完全可以在需要 B[] 的地方使用 A[]:

Integer[] intArray = new Integer[10];

Number[] numberArray = intArray;

上面的代码是有效的,因为一个 Integer 是一个 Number,因而一个 Integer 数组是 一个 Number 数组。但是对于泛型来说则不然。下面的代码是无效的:

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

最初,大多数 Java 程序员觉得这缺少协变很烦人,或者甚至是“坏的(broken)”,但是之所以这样有一个很好的原因。如果可以将 List<Integer> 赋给 List<Number>,下面的代码就会违背泛型应该提供的类型安全:

List<Integer> intList = new ArrayList<Integer>();

List<Number> numberList = intList; // invalid

numberList.add(new Float(3.1415));

因为 intList 和 numberList 都是有别名的,如果允许的话,上面的代码就会让您将不是 Integers 的东西放进 intList 中。但是,正如下一屏将会看到的,您有一个更加灵活的方式来定义泛型。

4.4 类型通配符

假设您具有该方法:

void printList(List l) {

for (Object o : l)

System.out.println(o);

}

上面的代码在 JDK 5.0 上编译通过,但是如果试图用 List<Integer> 调用它,则会得到警告。出现警告是因为,您将泛型(List<Integer>)传递给一个只承诺将它当作 List(所谓的原始类型)的方法,这将破坏使用泛型的类型安全。

如果试图编写像下面这样的方法,那么将会怎么样?

void printList(List<Object> l) {

for (Object o : l)

System.out.println(o);

}

它仍然不会通过编译,因为一个 List<Integer> 不是 一个 List<Object>(正如前一屏 泛型不是协变的 中所学的)。这才真正烦人 —— 现在您的泛型版本还没有普通的非泛型版本有用!

解决方案是使用类型通配符:

void printList(List<?> l) {

for (Object o : l)

System.out.println(o);

}

上面代码中的问号是一个类型通配符。它读作“问号”。List<?> 是任何泛型 List 的父类型,所以您完全可以将 List<Object>、List<Integer> 或 List<List<List<Flutzpah>>> 传递给 printList()。

4.5 类型通配符的作用

类型通配符中引入了类型通配符,这让您可以声明 List<?> 类型的变量。您可以对这样的 List 做什么呢?非常方便,可以从中检索元素,但是不能添加元素。原因不是编译器知道哪些方法修改列表哪些方法不修改列表,而是(大多数)变化的方法比不变化的方法需要更多的类型信息。下面的代码则工作得很好:

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

System.out.println(lu.get(0));

为什么该代码能工作呢?对于 lu,编译器一点都不知道 List 的类型参数的值。但是编译器比较聪明,它可以做一些类型推理。在本例中,它推断未知的类型参数必须扩展 Object。(这个特定的推理没有太大的跳跃,但是编译器可以作出一些非常令人佩服的类型推理,后面就会看到(在底层细节一节中)。所以它让您调用 List.get() 并推断返回类型为 Object。

另一方面,下面的代码不能工作:

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.add(new Integer(43)); // error

在本例中,对于 lu,编译器不能对 List 的类型参数作出足够严密的推理,以确定将 Integer 传递给 List.add() 是类型安全的。所以编译器将不允许您这么做。

以免您仍然认为编译器知道哪些方法更改列表的内容哪些不更改列表内容,请注意下面的代码将能工作,因为它不依赖于编译器必须知道关于 lu 的类型参数的任何信息:

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(42));

List<?> lu = li;

lu.clear();

4.6 泛型方法

(在 类型参数 一节中)您已经看到,通过在类的定义中添加一个形式类型参数列表,可以将类泛型化。方法也可以被泛型化,不管它们定义在其中的类是不是泛型化的。

泛型类在多个方法签名间实施类型约束。在 List<V> 中,类型参数 V 出现在 get()、add()、contains() 等方法的签名中。当创建一个 Map<K, V> 类型的变量时,您就在方法之间宣称一个类型约束。您传递给 add() 的值将与 get() 返回的值的类型相同。

类似地,之所以声明泛型方法,一般是因为您想要在该方法的多个参数之间宣称一个类型约束。例如,下面代码中的 ifThenElse() 方法,根据它的第一个参数的布尔值,它将返回第二个或第三个参数:

public <T> T ifThenElse(boolean b, T first, T second) {

return b ? first : second;

}

注意,您可以调用 ifThenElse(),而不用显式地告诉编译器,您想要 T 的什么值。编译器不必显式地被告知 T 将具有什么值;它只知道这些值都必须相同。编译器允许您调用下面的代码,因为编译器可以使用类型推理来推断出,替代 T 的 String 满足所有的类型约束:

String s = ifThenElse(b, "a", "b");

类似地,您可以调用:

Integer i = ifThenElse(b, new Integer(1), new Integer(2));

但是,编译器不允许下面的代码,因为没有类型会满足所需的类型约束:

String s = ifThenElse(b, "pi", new Float(3.14));

为什么您选择使用泛型方法,而不是将类型 T 添加到类定义呢?(至少)有两种情况应该这样做:

当泛型方法是静态的时,这种情况下不能使用类类型参数。

当 T 上的类型约束对于方法真正是局部的时,这意味着没有在相同类的另一个方法签名中使用相同类型 T 的约束。通过使得泛型方法的类型参数对于方法是局部的,可以简化封闭类型的签名。

4.7 有限制类型

在前一屏 泛型方法 的例子中,类型参数 V 是无约束的或无限制的类型。有时在还没有完全指定类型参数时,需要对类型参数指定附加的约束。

考虑例子 Matrix 类,它使用类型参数 V,该参数由 Number 类来限制:

public class Matrix<V extends Number> { ... }

编译器允许您创建 Matrix<Integer> 或 Matrix<Float> 类型的变量,但是如果您试图定义 Matrix<String> 类型的变量,则会出现错误。类型参数 V 被判断为由 Number 限制 。在没有类型限制时,假设类型参数由 Object 限制。这就是为什么前一屏 泛型方法 中的例子,允许 List.get() 在 List<?> 上调用时返回 Object,即使编译器不知道类型参数 V 的类型。

5. 一个简单的泛型类

5.1 编写基本的容器类

此时,您可以开始编写简单的泛型类了。到目前为止,泛型类最常见的用例是容器类(比如集合框架)或者值持有者类(比如 WeakReference 或 ThreadLocal)。我们来编写一个类,它类似于 List,充当一个容器。其中,我们使用泛型来表示这样一个约束,即 Lhist 的所有元素将具有相同类型。为了实现起来简单,Lhist 使用一个固定大小的数组来保存值,并且不接受 null 值。

Lhist 类将具有一个类型参数 V(该参数是 Lhist 中的值的类型),并将具有以下方法:

public class Lhist<V> {

public Lhist(int capacity) { ... }

public int size() { ... }

public void add(V value) { ... }

public void remove(V value) { ... }

public V get(int index) { ... }

}

要实例化 Lhist,只要在声明时指定类型参数和想要的容量:

Lhist<String> stringList = new Lhist<String>(10);

5.2 实现构造函数

在实现 Lhist 类时,您将会遇到的第一个拦路石是实现构造函数。您可能会像下面这样实现它:

public class Lhist<V> {

private V[] array;

public Lhist(int capacity) {

array = new V[capacity]; // illegal

}

}

这似乎是分配后备数组最自然的一种方式,但是不幸的是,您不能这样做。具体原因很复杂,当学习到底层细节一节中的“擦除”主题时,您就会明白。分配后备数组的实现方式很古怪且违反直觉。下面是构造函数的一种可能的实现(该实现使用集合类所采用的方法):

public class Lhist<V> {

private V[] array;

public Lhist(int capacity) {

array = (V[]) new Object[capacity];

}

}

另外,也可以使用反射来实例化数组。但是这样做需要给构造函数传递一个附加的参数 —— 一个类常量,比如 Foo.class。后面在 Class<T> 一节中将讨论类常量。

5.3 实现方法

实现 Lhist 的方法要容易得多。下面是 Lhist 类的完整实现:

public class Lhist<V> {

private V[] array;

private int size;

public Lhist(int capacity) {

array = (V[]) new Object[capacity];

}

public void add(V value) {

if (size == array.length)

throw new IndexOutOfBoundsException(Integer.toString(size));

else if (value == null)

throw new NullPointerException();

array[size++] = value;

}

public void remove(V value) {

int removalCount = 0;

for (int i=0; i<size; i++) {

if (array[i].equals(value))

++removalCount;

else if (removalCount > 0) {

array[i-removalCount] = array[i];

array[i] = null;

}

}

size -= removalCount;

}

public int size() { return size; }

public V get(int i) {

if (i >= size)

throw new IndexOutOfBoundsException(Integer.toString(i));

return array[i];

}

}

注意,您在将会接受或返回 V 的方法中使用了形式类型参数 V,但是您一点也不知道 V 具有什么样的方法或域,因为这些对泛型代码是不可知的。

5.4 使用 Lhist 类

使用 Lhist 类很容易。要定义一个整数 Lhist,只需要在声明和构造函数中为类型参数提供一个实际值即可:

Lhist<Integer> li = new Lhist<Integer>(30);

编译器知道,li.get() 返回的任何值都将是 Integer 类型,并且它还强制传递给 li.add() 或 li.remove() 的任何东西都是 Integer。除了实现构造函数的方式很古怪之外,您不需要做任何十分特殊的事情以使 Lhist 是一个泛型类。

6. Java类库中的泛型

6.1 集合类

到目前为止,Java 类库中泛型支持存在最多的地方就是集合框架。就像容器类是 C++ 语言中模板的主要动机一样(参阅附录 A:与 C++ 模板的比较)(尽管它们随后用于很多别的用途),改善集合类的类型安全是 Java 语言中泛型的主要动机。集合类也充当如何使用泛型的模型,因为它们演示了泛型的几乎所有的标准技巧和方言。

所有的标准集合接口都是泛型化的 —— Collection<V>、List<V>、Set<V> 和 Map<K,V>。类似地,集合接口的实现都是用相同类型参数泛型化的,所以 HashMap<K,V> 实现 Map<K,V> 等。

集合类也使用泛型的许多“技巧”和方言,比如上限通配符和下限通配符。例如,在接口 Collection<V> 中,addAll 方法是像下面这样定义的:

interface Collection<V> {

boolean addAll(Collection<? extends V>);

}

该定义组合了通配符类型参数和有限制类型参数,允许您将 Collection<Integer> 的内容添加到 Collection<Number>。

如果类库将 addAll() 定义为接受 Collection<V>,您就不能将 Collection<Integer> 的内容添加到 Collection<Number>。不是限制 addAll() 的参数是一个与您将要添加到的集合包含相同类型的集合,而有可能建立一个更合理的约束,即传递给 addAll() 的集合的元素 适合于添加到您的集合。有限制类型允许您这样做,并且使用有限制通配符使您不需要使用另一个不会用在其他任何地方的占位符名称。

应该可以将 addAll() 的类型参数定义为 Collection<V>。但是,这不但没什么用,而且还会改变 Collection 接口的语义,因为泛型版本的语义将会不同于非泛型版本的语义。这阐述了泛型化一个现有的类要比定义一个新的泛型类难得多,因为您必须注意不要更改类的语义或者破坏现有的非泛型代码。

作为泛型化一个类(如果不小心的话)如何会更改其语义的一个更加微妙的例子,注意 Collection.removeAll() 的参数的类型是 Collection<?>,而不是 Collection<? extends V>。这是因为传递混合类型的集合给 removeAll() 是可接受的,并且更加限制地定义 removeAll 将会更改方法的语义和有用性。

6.2 其他容器类

除了集合类之外,Java 类库中还有几个其他的类也充当值的容器。这些类包括 WeakReference、SoftReference 和 ThreadLocal。它们都已经在其包含的值的类型上泛型化了,所以 WeakReference<T> 是对 T 类型的对象的弱引用,ThreadLocal<T> 则是到 T 类型的线程局部变量的句柄。

6.3 泛型不止用于容器

泛型最常见最直观的使用是容器类,比如集合类或引用类(比如 WeakReference<T>)。Collection<V> 中类型参数的含义很明显 —— “一个所有值都是 V 类型的集合”。类似地,ThreadLocal<T> 也有一个明显的解释 —— “一个其类型是 T 的线程局部变量”。但是,泛型规格说明中没有指定容积。

像 Comparable<T> 或 Class<T> 这样的类中类型参数的含义更加微妙。有时,就像 Class<T> 中一样,类型变量主要是帮助编译器进行类型推理。有时,就像隐含的 Enum<E extends Enum<E>> 中一样,类型变量只是在类层次结构上加一个约束。

6.3.1 Comparable<T>

Comparable 接口已经泛型化了,所以实现 Comparable 的对象声明它可以与什么类型进行比较。(通常,这是对象本身的类型,但是有时也可能是父类。)

public interface Comparable<T> {

public boolean compareTo(T other);

}

所以 Comparable 接口包含一个类型参数 T,该参数是一个实现 Comparable 的类可以与之比较的对象的类型。这意味着如果定义一个实现 Comparable 的类,比如 String,就必须不仅声明类支持比较,还要声明它可与什么比较(通常是与它本身比较):

public class String implements Comparable<String> { ... }

现在来考虑一个二元 max() 方法的实现。您想要接受两个相同类型的参数,二者都是 Comparable,并且相互之间是 Comparable。幸运的是,如果使用泛型方法和有限制类型参数的话,这相当直观:

public static <T extends Comparable<T>> T max(T t1, T t2) {

if (t1.compareTo(t2) > 0)

return t1;

else

return t2;

}

在本例中,您定义了一个泛型方法,在类型 T 上泛型化,您约束该类型扩展(实现) Comparable<T>。两个参数都必须是 T 类型,这表示它们是相同类型,支持比较,并且相互可比较。容易!

更好的是,编译器将使用类型推理来确定当调用 max() 时 T 的值表示什么意思。所以根本不用指定 T,下面的调用就能工作:

String s = max("moo", "bark");

编译器将计算出 T 的预定值是 String,因此它将进行编译和类型检查。但是如果您试图用不实现 Comparable<X> 的 类 X 的参数调用 max(),那么编译器将不允许这样做。

6.3.2 Class<T>

类 Class 已经泛型化了,但是很多人一开始都感觉其泛型化的方式很混乱。Class<T> 中类型参数 T 的含义是什么?事实证明它是所引用的类接口。怎么会是这样的呢?那是一个循环推理?如果不是的话,为什么这样定义它?

在以前的 JDK 中,Class.newInstance() 方法的定义返回 Object,您很可能要将该返回类型强制转换为另一种类型:

class Class {

Object newInstance();

}

但是使用泛型,您定义 Class.newInstance() 方法具有一个更加特定的返回类型:

class Class<T> {

T newInstance();

}

如何创建一个 Class<T> 类型的实例?就像使用非泛型代码一样,有两种方式:调用方法 Class.forName() 或者使用类常量 X.class。Class.forName() 被定义为返回 Class<?>。另一方面,类常量 X.class 被定义为具有类型 Class<X>,所以 String.class 是 Class<String> 类型的。

让 Foo.class 是 Class<Foo> 类型的有什么好处?大的好处是,通过类型推理的魔力,可以提高使用反射的代码的类型安全。另外,还不需要将 Foo.class.newInstance() 强制类型转换为 Foo。

考虑一个方法,它从数据库检索一组对象,并返回 JavaBeans 对象的一个集合。您通过反射来实例化和初始化创建的对象,但是这并不意味着类型安全必须完全被抛至脑后。考虑下面这个方法:

public static<T> List<T> getRecords(Class<T> c, Selector s) {

// Use Selector to select rows

List<T> list = new ArrayList<T>();

for (/* iterate over results */) {

T row = c.newInstance();

// use reflection to set fields from result

list.add(row);

}

return list;

}

可以像下面这样简单地调用该方法:

List<FooRecord> l = getRecords(FooRecord.class, fooSelector);

编译器将会根据 FooRecord.class 是 Class<FooRecord> 类型的这一事实,推断 getRecords() 的返回类型。您使用类常量来构造新的实例并提供编译器在类型检查中要用到的类型信息。

6.3.3 用 Class<T> 替换 T[]

Collection 接口包含一个方法,用于将集合的内容复制到一个调用者指定类型的数组中:

public Object[] toArray(Object[] prototypeArray) { ... }

toArray(Object[]) 的语义是,如果传递的数组足够大,就会使用它来保存结果,否则,就会使用反射分配一个相同类型的新数组。一般来说,单独传递一个数组作为参数来提供想要的返回类型是一个小技巧,但是在引入泛型之前,这是与方法交流类型信息最方便的方式。

有了泛型,就可以用一种更加直观的方式来做这件事。不像上面这样定义 toArray(),泛型 toArray() 可能看起来像下面这样:

public<T> T[] toArray(Class<T> returnType)

调用这样一个 toArray() 方法很简单:

FooBar[] fba = something.toArray(FooBar.class);

Collection 接口还没有改变为使用该技术,因为这会破坏许多现有的集合实现。但是如果使用泛型从新构建 Collection,则当然会使用该方言来指定它想要返回值是哪种类型。

6.3.4 Enum<E>

JDK 5.0 中 Java 语言另一个增加的特性是枚举。当您使用 enum 关键字声明一个枚举时,编译器就会在内部为您生成一个类,用于扩展 Enum 并为枚举的每个值声明静态实例。所以如果您说:

public enum Suit {HEART, DIAMOND, CLUB, SPADE};

编译器就会在内部生成一个叫做 Suit 的类,该类扩展 java.lang.Enum<Suit> 并具有叫做 HEART、DIAMOND、CLUB 和 SPADE 的常量(public static final)成员,每个成员都是 Suit 类。

与 Class 一样,Enum 也是一个泛型类。但是与 Class 不同,它的签名稍微更复杂一些:

class Enum<E extends Enum<E>> { . . . }

这究竟是什么意思?这难道不会导致无限递归?

我们逐步来分析。类型参数 E 用于 Enum 的各种方法中,比如 compareTo() 或 getDeclaringClass()。为了这些方法的类型安全,Enum 类必须在枚举的类上泛型化。

所以 extends Enum<E> 部分如何理解?该部分又具有两个部分。第一部分指出,作为 Enum 的类型参数的类本身必须是 Enum 的子类型,所以您不能声明一个类 X 扩展 Enum<Integer>。第二部分指出,任何扩展 Enum 的类必须传递它本身 作为类型参数。您不能声明 X 扩展 Enum<Y>,即使 Y 扩展 Enum。

总之,Enum 是一个参数化的类型,只可以为它的子类型实例化,并且这些子类型然后将根据子类型来继承方法。幸运的是,在 Enum 情况下,编译器为您做这些工作,一切都很好。

6.3.5 与非泛型代码相互操作

数百万行现有代码使用已经泛型化的 Java 类库中的类,比如集合框架、Class 和 ThreadLocal。JDK 5.0 中的改进不要破坏所有这些代码是很重要的,所以编译器允许您在不指定其类型参数的情况下使用泛型类。

当然,以“旧方式”做事没有新方式安全,因为忽略了编译器准备提供的类型安全。如果您试图将 List<String> 传递给一个接受 List 的方法,它将能够工作,但是编译器将会发出一个可能丧失类型安全的警告,即所谓的“unchecked conversion(不检查转换)”警告。

没有类型参数的泛型,比如声明为 List 类型而不是 List<Something> 类型的变量,叫做原始类型。原始类型与参数化类型的任何实例化是赋值兼容的,但是这样的赋值会生成 unchecked-conversion 警告。

为了消除一些 unchecked-conversion 警告,假设您不准备泛型化所有的代码,您可以使用通配符类型参数。使用 List<?> 而不使用 List。List 是原始类型;List<?> 是具有未知类型参数的泛型。编译器将以不同的方式对待它们,并很可能发出更少的警告。

无论在哪种情况下,编译器在生成字节码时都会生成强制类型转换,所以生成的字节码在每种情况下都不会比没有泛型时更不安全。如果您设法通过使用原始类型或类文件来破坏类型安全,就会得到与不使用泛型时得到的相同的 ClassCastException 或 ArrayStoreException。

7. Java 泛型的理解与等价实现

泛型是JAVA SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

JAVA语言引入泛型的好处是安全简单。

在JAVA SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。

泛型在使用中还有一些规则和限制:

1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上成为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String);

泛型还有接口、方法等等,内容很多,需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子(根据看的印象写的),实现同样的功能,一个使用了泛型,一个没有使用,通过对比,可以很快学会泛型的应用,学会这个基本上学会了泛型70%的内容。

估计你快等不及了,现在就贴出源码:

例子一:使用了泛型

public class Gen<T> {

    private T ob;   //定义泛型成员变量

    public Gen(T ob) {

        this.ob = ob;

    }

    public T getOb() {

        return ob;

    }

    public void setOb(T ob) {

        this.ob = ob;

    }

    public void showTyep() {

        System.out.println("T的实际类型是: " + ob.getClass().getName());

    }

}

public class GenDemo {

    public static void main(String[] args){

        //定义泛型类Gen的一个Integer版本

        Gen<Integer> intOb=new Gen<Integer>(88);

        intOb.showTyep();

        int i= intOb.getOb();

        System.out.println("value= " + i);

        System.out.println("----------------------------------");

        //定义泛型类Gen的一个String版本

        Gen<String> strOb=new Gen<String>("Hello Gen!");

        strOb.showTyep();

        String s=strOb.getOb();

        System.out.println("value= " + s);

    }

}

例子二:没有使用泛型

public class Gen2 {

    private Object ob;      //定义一个通用类型成员

    public Gen2(Object ob) {

        this.ob = ob;

    }

    public Object getOb() {

        return ob;

    }

    public void setOb(Object ob) {

        this.ob = ob;

    }

    public void showTyep() {

        System.out.println("T的实际类型是: " + ob.getClass().getName());

    }

}

public class GenDemo2 {

    public static void main(String[] args) {

        //定义类Gen2的一个Integer版本

        Gen2 intOb = new Gen2(new Integer(88));

        intOb.showTyep();

        int i = (Integer) intOb.getOb();

        System.out.println("value= " + i);

        System.out.println("----------------------------------");

        //定义类Gen2的一个String版本

        Gen2 strOb = new Gen2("Hello Gen!");

        strOb.showTyep();

        String s = (String) strOb.getOb();

        System.out.println("value= " + s);

    }

}

8. Java5泛型的用法,T.class的获取

Java 5的泛型语法已经有太多书讲了,这里不再打字贴书。GP一定有用,不然Java和C#不会约好了似的同时开始支持GP。但大家也清楚,GP和Ruby式的动态OO语言属于不同的意识形态,如果是一人一票,我想大部分的平民程序员更热衷动态OO语言的平白自然。但如果不准备跳槽到支持JSR223的动态语言,那还是看看GP吧。

胡乱总结泛型的四点作用:

第一是泛化,可以拿个T代表任意类型。但GP是被C++严苛的静态性逼出来的,落到Java、C#这样的花语平原里----所有对象除几个原始类型外都派生于Object,再加上Java的反射功能,Java的Collection库没有范型一样过得好好的。

第二是泛型 + 反射,原本因为Java的泛型拿不到T.class而觉得泛型没用,最近才刚刚学到通过反射的API来获取T的Class,后述。

第三是收敛,就是增加了类型安全,减少了强制类型转换的代码。这点倒是Java Collection历来的弱项。

第四是可以在编译期搞很多东西,比如MetaProgramming。但除非能完全封闭于框架内部,框架的使用者和扩展者都不用学习这些东西的用法,否则那就是自绝于人民的票房毒药。C++的MetaProgramming好厉害吧,但对比一下Python拿Meta Programming生造一个Class出来的简便语法,就明白什么才是真正的叫好又叫座。

所以,作为一个架构设计师,应该使用上述的第2,3项用法,在框架类里配合使用反射和泛型,使得框架的能力更强; 同时采用收敛特性,本着对人民负责的精神,用泛型使框架更加类型安全,更少强制类型转换。

擦拭法避免了Java的流血分裂 :

大家经常骂Java GP的擦拭法实现,但我觉得多亏于它的中庸特性---如果你用就是范型,不用就是普通Object,避免了Java阵营又要经历一场to be or not to be的分裂。

最大的例子莫过Java 5的Collection 框架, 比如有些同学坚持认为自己不会白痴到类型出错,而且难以忍受每个定义的地方都要带一个泛型定义List〈Book〉,不用强制类型转换所省下的代码还不够N处定义花的(对了,java里面还没有tyepdef.....),因此对范型十分不感冒,这时就要齐齐感谢这个搽拭法让你依然可以对一个泛型框架保持非泛型的用法了...

通过反射获得 T.class:

不知为何书上不怎么讲这个,是差沙告诉我才知道的,最经典的应用见Hibernate wiki的Generic Data Access Objects, 代码如下

abstract public class BaseHibernateEntityDao<T> extends HibernateDaoSupport {

    private Class<T> entityClass;

    public BaseHibernateEntityDao() {

        entityClass =(Class<T>) ((ParameterizedType) getClass()

            .getGenericSuperclass()).getActualTypeArguments()[0];

    }

    public T get(Serializable id) {

        T o = (T) getHibernateTemplate().get(entityClass, id);

    }

}

精华就是这句了:

Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]; 

泛型之后,所有BaseHibernateEntityDao的子类只要定义了泛型,就无需再重载getEnttityClass(),get()函数和find()函数,销益挺明显的,所以SpringSide的Dao基类毫不犹豫就泛型了。

不过擦拭法的大棒仍在,所以子类的泛型语法可不能乱写,最正确的用法只有:

public class BookDao extends BaseHibernateEntityDao<Book>

9. Java 5.0泛型编程之泛型类型

Java5.0的新特性之一是引入了泛型类型和泛型方法。一个泛型类型通过使用一个或多个类型变量来定义,并拥有一个或多个使用一个类型变量作为一个参数或者返回值的占位符。例如,类型java.util.List<E>是一个泛型类型:一个list,其元素的类型被占位符E描述。这个类型有一个名为add()的方法,被声明为有一个类型为E的参数,同时,有一个get()方法,返回值被声明为E类型。

使用泛型类型,你应该为类型变量详细指明实际的类型,形成一个就像List<String>类似的参数化类型。[1]指明这些额外的类型信息的原因是编译器据此能够在编译期为您提供很强的类型检查,增强您的程序的类型安全性。举个例子来说,您有一个只能保持String对象的List,那么这种类型检查就能够阻止您往里面加入String[]对象。同样的,增加的类型信息使编译器能够为您做一些类型转换的事情。比如,编译器知道了一个List<String>有个get()方法,其返回值是一个String对象,因此您不再需要去将返回值由一个Object强制转换为String。

Java.util包中的集合类在java5.0中已经被做成了泛型,也许您将会在您的程序中频繁的使用到他们。类型安全的集合类就是一个泛型类型的典型案例。即便您从没有定义过您自己的泛型类型甚至从未用过除了java.util中的集合类以外的泛型类型,类型安全的集合类的好处也是极有意义的一个标志——他们证明了这个主要的新语言特性的复杂性。

我们从探索类型安全的集合类中的基本的泛型用法开始,进而研究更多使用泛型类型的复杂细节。然后我们讨论类型参数通配符和有界通配符。描绘了如何使用泛型以后,我们阐明如何编写自己的泛型类型和泛型方法。我们对于泛型的讨论将结束于一趟对于JavaAPI的核心中重要的泛型类型的旅行。这趟旅程将探索这些类型以及他们的用法,旅程的目的是为了让您对泛型如何工作这个问题有个深入的理解。

类型安全集合类

Java.util类包包含了Java集合框架(Java Collections Framework),这是一批包含对象的set、对象的list以及基于key-value的map。第五章将谈到集合类。这里,我们讨论的是在 java5.0中集合类使用类型参数来界定集合中的对象的类型。这个讨论并不适合java1.4或更早期版本。如果没有泛型,对于集合类的使用需要程序员记住每个集合中元素的类型。当您在java1.4种创建了一个集合,您知道您放入到集合中的对象的类型,但是编译器不知道。您必须小心地往其中加入一个合适类型的元素,当需要从集合中获取元素时,您必须显式的写强制类型转换以将他们从Object转换为他们真是的类型。考察下边的java1.4的代码。

public static void main(String[] args) {

// This list is intended to hold only strings.

// The compiler doesn't know that so we have to remember ourselves.

List wordlist = new ArrayList();  

// Oops! We added a String[] instead of a String.

// The compiler doesn't know that this is an error.

wordlist.add(args);

// Since List can hold arbitrary objects, the get() method returns

// Object.  Since the list is intended to hold strings, we cast the

// return value to String but get a ClassCastException because of

// the error above.

String word = (String)wordlist.get(0);

}

泛型类型解决了这段代码中的显示的类型安全问题。Java.util中的List或是其他集合类已经使用泛型重写过了。就像前面提到的, List被重新定义为一个list,它中间的元素类型被一个类型可变的名称为E的占位符描述。Add()方法被重新定义为期望一个类型为E的参数,用于替换以前的Object,get()方法被重新定义为返回一个E,替换了以前的Object。

在java5.0中,当我们申明一个List或者创建一个ArrayList的实例的时候,我们需要在泛型类型的名字后面紧跟一对“<>”,尖括号中写入我们需要的实际的类型。比如,一个保持String的List应该写成 “List<String>”。需要注意的是,这非常象给一个方法传一个参数,区别是我们使用类型而不是值,同时使用尖括号而不是圆括号

Java.util的集合类中的元素必须是对象化的,他们不能是基本类型。泛型的引入并没有改变这点。泛型不能使用基本类型:我们不能这样来申明——Set<char>或者List<int>。记住,无论如何,java5.0中的自动打包和自动解包特性使得使用Set<Character>或者List<Integer>和直接使用 char和int值一样方便。

在Java5.0中,上面的例子将被重写为如下方式:

public static void main(String[] args) {

// This list can only hold String objects

List<String> wordlist = new ArrayList<String>();

// args is a String[], not String, so the compiler won't let us do this

wordlist.add(args);  // Compilation error!

// We can do this, though.  

// Notice the use of the new for/in looping statement

for(String arg : args) wordlist.add(arg);

// No cast is required.  List<String>.get() returns a String.

String word = wordlist.get(0);

}

值得注意的是代码量其实并没有比原来那个没有泛型的例子少多少。使用 “(String)”这样的类型转换被替换成了类型参数“<String>”。不同的是类型参数需要且仅需要声明一次,而list能够被使用任何多次,不需要类型转换。在更长点的例子代码中,这一点将更加明显。即使在那些看上去泛型语法比非泛型语法要冗长的例子里,使用泛型依然是非常有价值的 ——额外的类型信息允许编译器在您的代码里执行更强的错误检查。以前只能在运行起才能发现的错误现在能够在编译时就被发现。此外,以前为了处理类型转换的异常,我们需要添加额外的代码行。如果没有泛型,那么当发生类型转换异常的时候,一个ClassCastException异常就会被从实际代码中抛出。

就像一个方法可以使用任意数量的参数一样,类允许使用多个类型变量。接口 Java.util.Map就是一个例子。一个Map体现了从一个key的对象到一个value的对象的映射关系。接口Map申明了一个类型变量来描述 key的类型而另一个类型变量来描述value的类型。举个例子来说,假设您希望做一个String对象到Integer对象的映射关系:

public static void main(String[] args) {

// A map from strings to their position in the args[] array

Map<String,Integer> map = new HashMap<String,Integer>();

// Note that we use autoboxing to wrap i in an Integer object.

for(int i=0; i < args.length; i++)

    map.put(args[i], i);  

// Find the array index of a word.  Note no cast is required!

Integer position = map.get("hello");

// We can also rely on autounboxing to convert directly to an int,

// but this throws a NullPointerException if the key does not exist in the map

int pos = map.get("world");

}

象List<String>这个一个参数类型其本身也是也一个类型,也能够被用于当作其他类型的一个类型变量值。您可能会看到这样的代码:

// Look at all those nested angle brackets!

Map<String, List<List<int[]>>> map = getWeirdMap();

// The compiler knows all the types and we can write expressions

// like this without casting.  We might still get NullPointerException

// or ArrayIndexOutOfBounds at runtime, of course.

int value = map.get(key).get(0).get(0)[0];

 

// Here's how we break that expression down step by step.

List<List<int[]>> listOfLists = map.get(key);

List<int[]> listOfIntArrays = listOfLists.get(0);

int[] array = listOfIntArrays.get(0);

int element = array[0];

在上面的代码里,java.util.List<E>和 java.util.Map<K,V>的get()方法返回一个类型为E的list元素或者一个类型为V的map元素。注意,无论如何,泛型类型能够更精密的使用他们的变量。在本书中的参考章节查看List<E>,您将会看到它的iterator( )方法被声明为返回一个Iterator<E>。这意味着,这个方法返回一个跟list的实际的参数类型一样的一个参数类型的实例。为了具体的说明这点,下面的例子提供了不使用get(0)方法来获取一个List<String>的第一个元素的方法。

List<String> words = // ...initialized elsewhere...

Iterator<String> iterator = words.iterator();

String firstword = iterator.next();

10.    理解泛型类型

本段将对泛型类型的使用细节做进一步的探讨,以尝试说明下列问题:

不带类型参数的使用泛型的后果

参数化类型的体系

一个关于编译期泛型类型的类型安全的漏洞和一个用于确保运行期类型安全的补丁

为什么参数化类型的数组不是类型安全的

未经处理的类型和不被检查的警告

即使被重写的Java集合类带来了泛型的好处,在使用他们的时候您也不被要求说明类型变量。一个不带类型变量的泛型类型被认为是一个未经处理的类型(raw type)。这样,5.0版本以前的java代码仍然能够运行:您显式的编写所有类型转换就像您已经这样写的一样,您可能会被一些来自编译器的麻烦所困扰。查看下列存储不同类型的对象到一个未经处理的List:

List l = new ArrayList();

l.add("hello");  

l.add(new Integer(123));

Object o = l.get(0);

这段代码在java1.4下运行得很好。如果您用java5.0来编译它,javac编译了,但是会打印出这样的“抱怨”:

Note: Test.java uses unchecked or unsafe operations.

Note: Recompile with -Xlint:unchecked for details.

如果我们加入-Xlint参数后重新编译,我们会看到这些警告:

Test.java:6: warning: [unchecked]

unchecked call to add(E) as a member of the raw type java.util.List

l.add("hello");  

Test.java:7: warning: [unchecked]

unchecked call to add(E) as a member of the raw type java.util.List

l.add(new Integer(123));

编译在add()方法的调用上给出了警告,因为它不能够确信加入到list中的值具有正确的类型。它告诉我们说我们使用了一个未经处理的类型,它不能验证我们的代码是类型安全的。注意,get()方法的调用是没有问题的,因为能够被获得的元素已经安全的存在于list中了。

如果您不想使用任何的java5.0的新特性,您可以简单的通过带-source1.4标记来编译他们,这样编译器就不会再“抱怨”了。如果您不能这样做,您可以忽略这些警告,通过使用一个“@SuppressWarnings("unchecked")”注解(查看本章的4.3节)隐瞒这些警告信息或者升级您的代码,加入类型变量描述。[2]下列示例代码,编译的时候不再会有警告但仍然允许您往list中放入不同的类型的对象。

List<Object> l = new ArrayList<Object>();

l.add("hello");  

l.add(123);              // autoboxing

Object o = l.get(0);

参数化类型的体系

参数化类型有类型体系,就像一般的类型一样。这个体系基于对象的类型,而不是变量的类型。这里有些例子您可以尝试:

ArrayList<Integer> l = new ArrayList<Integer>();

List<Integer> m = l;                            // okay

Collection<Integer> n = l;                      // okay

ArrayList<Number> o = l;                        // error

Collection<Object> p = (Collection<Object>)l;   // error, even with cast

一个List<Integer>是一个Collection<Integer>,但不是一个List<Object>。这句话不容易理解,如果您想理解为什么泛型这样做,这段值得看一下。考察这段代码:

List<Integer> li = new ArrayList<Integer>();

li.add(123);

// The line below will not compile.  But for the purposes of this

// thought-experiment, assume that it does compile and see how much

// trouble we get ourselves into.

List<Object> lo = li;  

// Now we can retrieve elements of the list as Object instead of Integer

Object number = lo.get(0);

// But what about this?

lo.add("hello world");

// If the line above is allowed then the line below throws ClassCastException

Integer i = li.get(1);  // Can't cast a String to Integer!

这就是为什么List<Integer>不是一个 List<Object>的原因,虽然List<Integer>中所有的元素事实上是一个Object的实例。如果允许转换成 List<Object>,那么转换后,理论上非整型的对象也将被允许添加到list中。

1

运行时类型安全

就像我们所见到的,一个List<X>不允许被转换为一个List<Y>,即使这个X能够被转换为Y。然而,一个List<X>能够被转换为一个List,这样您就可以通过继承的方法来做这样的事情。

这种将参数化类型转换为非参数化类型的能力对于向下兼容是必要的,但是它会在泛型所带来的类型安全体系上凿个漏洞:

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();

// It is legal to assign a parameterized type to a nonparameterized variable

List l = li;  

// This line is a bug, but it compiles and runs.

// The Java 5.0 compiler will issue an unchecked warning about it.

// If it appeared as part of a legacy class compiled with Java 1.4, however,

// then we'd never even get the warning.  

l.add("hello");

// This line compiles without warning but throws ClassCastException at runtime.

// Note that the failure can occur far away from the actual bug.

Integer i = li.get(0);

泛型仅提供了编译期的类型安全。如果您使用java5.0的编译器来编译您的代码并且没有得到任何警告,这些编译器的检查能够确保您的代码在运行期也是类型安全的。如果您获得了警告或者使用了像未经处理的类型那样修改您的集合的代码,那么您需要增加一些步骤来确保运行期的类型安全。您可以通过使用java.util.Collections中的checkedList()和 checkedMap( )方法来做到这一步。这些方法将把您的集合打包成一个wrapper集合,从而在运行时检查确认只有正确类型的值能够被置入集合众。下面是一个能够补上类型安全漏洞的一个例子:

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();

// Wrap it for runtime type safety

List<Integer> cli = Collections.checkedList(li, Integer.class);

// Now widen the checked list to the raw type

List l = cli;  

// This line compiles but fails at runtime with a ClassCastException.

// The exception occurs exactly where the bug is, rather than far away

l.add("hello");

参数化类型的数组

在使用泛型类型的时候,数组需要特别的考虑。回忆一下,如果T是S的父类(或者接口),那么类型为S的数组S[],同时又是类型为T的数组T[]。正因为如此,每次您存放一个对象到数组中时,Java解释器都必须进行检查以确保您放入的对象类型与要存放的数组所允许的类型是匹对的。例如,下列代码在运行期会检查失败,抛出一个ArrayStoreException异常:

String[] words = new String[10];

Object[] objs = words;

objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

虽然编译时obj是一个Object[],但是在运行时它是一个String[],它不允许被用于存放一个Integer。

当我们使用泛型类型的时候,仅仅依靠运行时的数组存放异常检查是不够的,因为一个运行时进行的检查并不能够获取编译时的类型参数信息。查看下列代码:

List<String>[] wordlists = new ArrayList<String>[10];

ArrayList<Integer> ali = new ArrayList<Integer>();

ali.add(123);

Object[] objs = wordlists;

objs[0] = ali;                       // No ArrayStoreException

String s = wordlists[0].get(0);      // ClassCastException!

如果上面的代码被允许,那么运行时的数组存储检查将会成功:没有编译时的类型参数,代码简单地存储一个ArrayList到一个ArrayList[]数组,非常正确。既然编译器不能阻止您通过这个方法来战胜类型安全,那么它转而阻止您创建一个参数化类型的数组。所以上述情节永远不会发生,编译器在第一行就开始拒绝编译了。

注意这并不是一个在使用数组时使用泛型的全部的约束,这仅仅是一个创建一个参数化类型数组的约束。我们将在学习如何写泛型方法时再来讨论这个话题。

类型参数通配符

假设我们需要写一个方法来显示一个List中的元素。[3]在以前,我们只需要象这样写段代码:

public static void printList(PrintWriter out, List list) {

for(int i=0, n=list.size(); i < n; i++) {

     if (i > 0)

         out.print(", ");

     out.print(list.get(i).toString());

 }

}

在Java5.0中,List是一个泛型类型,如果我们试图编译这个方法,我们将会得到unchecked警告。为了解决这些警告,您可能需要这样来修改这个方法:

public static void printList(PrintWriter out, List<Object> list) {

for(int i=0, n=list.size(); i < n; i++) {

   if (i > 0)

       out.print(", ");

   out.print(list.get(i).toString());

    }

}

这段代码能够编译通过同时不会有警告,但是它并不是非常地有效,因为只有那些被声明为 List<Object>的list才会被允许使用这个方法。还记得么,类似于List<String>和 List<Integer>这样的List并不能被转型为List<Object>。事实上我们需要一个类型安全的 printList()方法,它能够接受我们传入的任何List,而不关心它被参数化为什么。解决办法是使用类型参数通配符。方法可以被修改成这样:

public static void printList(PrintWriter out, List<?> list) {

for(int i=0, n=list.size(); i < n; i++) {

    if (i > 0)

        out.print(", ");

        Object o = list.get(i);

        out.print(o.toString());

}

}

这个版本的方法能够被编译过,没有警告,而且能够在任何我们希望使用的地方使用。通配符“?”表示一个未知类型,类型List<?>被读作“List of unknown”

作为一般原则,如果类型是泛型的,同时您并不知道或者并不关心值的类型,您应该使用 “?”通配符来代替一个未经处理的类型。未经处理的类型被允许仅是为了向下兼容,而且应该只能够被允许出现在老的代码中。注意,无论如何,您不能在调用构造器时使用通配符。下面的代码是非法的:

List<?> l = new ArrayList<?>();

创建一个不知道类型的List是毫无道理的。如果您创建了它,那么您必须知道它将保持的元素是什么类型的。您可以在随后的方法中不关心元素类型而去遍历这里list,但是您需要在您创建它的时候描述元素的类型。如果你确实需要一个List 来保持任何类型,那么您只能这么写:

List<Object> l = new ArrayList<Object>();

从上面的printList()例子中,必须要搞清楚List<?>既不是List<Object>也不是一个未经处理的List。一个使用通配符的List<?>有两个重要的特性。第一,考察类似于 get()的方法,他们被声明返回一个值,这个值的类型是类型参数中指定的。在这个例子中,类型是“unknown”,所以这些方法返回一个 Object。既然我们期望的是调用这个object的toString()方法,程序能够很好的满足我们的意愿。

第二,考察List的类似add()的方法,他们被声明为接受一个参数,这个参数被类型参数所定义。出人意料的是,当类型参数是未确定的,编译器不允许您调用任何有不确定参数类型的方法——因为它不能确认您传入了一个恰当的值。一个 List(?)实际上是只读的——既然编译器不允许我们调用类似于add(),set(),addAll()这类的方法。

界定通配符

让我们在我们原来的例子上作些小小的稍微复杂一点的改动。假设我们希望写一个 sumList()方法来计算list中Number类型的值的合计。在以前,我们使用未经处理的List,但是我们不想放弃类型安全,同时不得不处理来自编译器的unchecked警告。或者我们可以使用List<Number>,那样的话我们就不能调用 List<Integer>、List<Double>中的方法了,而事实上我们需要调用。如果我们使用通配符,那么我们实际上不能得到我们期望的类型安全,我们不能确定我们的方法被什么样的List所调用,Number?还是Number的子类?甚至,String?这样的一个方法也许会被写成这样:

public static double sumList(List<?> list) {

double total = 0.0;

for(Object o : list) {

    Number n = (Number) o;  // A cast is required and may fail

    total += n.doubleValue();

}

return total;

}

要修改这个方法让它变得真正的类型安全,我们需要使用界定通配符(bounded wildcard),能够确保List的类型参数是未知的,但又是Number或者Number的子类。下面的代码才是我们想要的:

public static double sumList(List<? extends Number> list) {

double total = 0.0;

for(Number n : list) total += n.doubleValue();

return total;

}

类型List<? extends Number>可以被理解为“Number未知子类的List”。理解这点非常重要,在这段文字中,Number被认为是其自身的子类。

注意,这样的话,那些类型转换已经不再需要了。我们并不知道list中元素的具体类型,但是我们知道他们能够向上转型为Number,因此我们可以把他们从list中把他们当作一个Number对象取出。使用一个for/in循环能够稍微封装一下从list中取出元素的过程。普遍性的原则是当您使用一个界定通配符时,类似于List中的get()方法的那些方法将返回一个类型为上界的值。因此如果我们在for/in循环中调用list.get(),我们将得到一个Number。在前一节说到使用通配符时类似于list.add()这种方法中的限制依然有效:举个例子来说,如果编译器允许我们调用这类方法,我们就可以将一个Integer放到一个声明为仅保持Short值的list中去。

同样可行的是使用下界通配符,不同的是用super替换extends。这个技巧在被调用的方法上有一点不同的作用。在实际应用中,下界通配符要比上界通配符用得少。我们将在后面的章节里讨论这个问题。