泛型ch15

写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。

在面向对象编程语言中，多态算是一种泛化机制。例如，你可以将方法的参数类型设为基类，那么该方法就可以接受从这个基类中导出的任何类作为参数。这样的方法更加通用一些，

类不能扩展，其他任何类都可以被扩展，

有时候，拘泥于单继承体系，也会使程序受限太多。如果方法的参数是一个接口，而不是617

可以不用参考C++。我也是尽力这样做的，除非，与C++的比较能够加深你的理解。

Java 中的泛型就需要与C++进行一番比较，理由有二：首先，了解C++模板的某些方面，有助于你理解泛型的基础。同时，非常重要的一点是，你可以了解Java 泛型的局限是什么，以及为什么会有这些限制。最终的目的是帮助你理解，Java 泛型的边界在哪里。根据我的经验，理解了边界所在，你才能成为程序高手。因为只有知道了某个技术不能做到什么，你才能更好地做到所能做的（部分原因是，不必浪费时间在死胡同里乱转）。

第二个原因是，在Java 社区中，人们普遍对C++模板有一种误解，而这种误解可能会误导你，令你在理解泛型的意图时产生偏差。

因此，在本章中会介绍一些C++模板的例子，不过我也会尽量控制它们的篇幅。

15.2 简单泛型

有许多原因促成了泛型的出现，而最引人注目的一个原因，就是为了创造容器类。（关于容器类，你可以参考第11章和第17章这两章。）容器，就是存放要使用的对象的地方。数组也是如此，不过与简单的数组相比，容器类更加灵活，具备更多不同的功能。事实上，所有的程序，在运行时都要求你持有一大堆对象，所以，容器类算得上最具重用性的类库之一。

我们先来看看一个只能持有单个对象的类。当然了，这个类可以明确指定其持有的对象的类型：不过，这个类的可重用性就不怎么样了，它无法持有其他类型的任何对象。我们可不希望为碰到的每个类型都编写一个新的类。在Java SE5之前，我们可以让这个类直接持有

Object 类型的对象：

现在，Holder2可以存储任何类型的对象，在这个例子中，只用了一个Holder2对象，却先后三次存储了三种不同类型的对象。有些情况下，我们确实希望容器能够同时持有多种类型的对象。但是，通常而言，我们只会使用容器来存储一种类型的对象。泛型的主要目的之一就是用来指定容器要持有什么类型的泛型353618619

对象，而且由编译器来保证类型的正确性。

因此，与其使用Object ，我们更喜欢暂时不指定类型，而是稍后再决定具体使用什么类型。要达到这个目的，需要使用类型参数，用尖括号括住，放在类名后面。然后在使用这个类的时候，再用实际的类型替换此类型参数。在下面的例子中，T 就是类型参数：现在，当你创建

Holder3对象时，必须指明想持有什么类型的对象，将其置于尖括号内。就像main()

中那样。然后，你就只能在Holder3中存入该类型（或其子类，因为多态与泛型不冲突）的对象了。并且，在你从

Holder3中取出它持有的对象时，自动地就是正确的类型。

这就是Java 泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。一般而言，你可以认为泛型与其他的类型差不多，只不过它们碰巧有类型参数罢了。稍后

我们会看到，在使用泛型时，我们只需指定它们的名称以及类型参数列表即可。练习1：(1) 配合typeinfo.pets 类库，用Holder3来证明，如果指定Holder3可以持有某个基类类型，那么它也能持有导出类型。

练习2：(1) 创建一个Holder 类，使其能够持有具有相同类型的3个对象，并提供相应的读写方法访问这些对象，以及一个可以初始化其持有的3个对象的构造器。

15.2.1 一个元组类库

仅一次方法调用就能返回多个对象，你应该经常需要这样的功能吧。可是return 语句只允许返回单个对象，因此，解决办法就是创建一个对象，用它来持有想要返回的多个对象。当然，可以在每次需要的时候，专门创建一个类来完成这样的工作。可是有了泛型，我们就能够一次性地解决该问题，以后再也不用在这个问题上浪费时间了。同时，我们在编译期就能确保类型安全。

这个概念称为元组（tuple ），它是将一组对象直接打包存储于其中的一个单一对象。这个容器对象允许读取其中元素，但是不允许向其中存放新的对象。（这个概念也称为数据传送对象，或信使。）

通常，元组可以具有任意长度，同时，元组中的对象可以是任意不同的类型。不过，我们希望能够为每一个对象指明其类型，并且从容器中读取出来时，能够得到正确的类型。要处理不同长度的问题，我们需要创建多个不同的元组。下面的程序是一个2维元组，它能够持有两个对象：

354第15 章620

621

构造器捕获了要存储的对象，而toString()

是一个便利函数，用来显示列表中的值。注意，元组隐含地保持了其中元素的次序。

第一次阅读上面的代码时，你也许会想，这不是违反了Java 编程的安全性原则吗？

first 和second 应该声明为private ，然后提供getFirst()和getSecond()之类的访问方法才对呀？让我们仔细看看这个例子中的安全性：客户端程序可以读取first 和second 对象，然后可以随心所欲地使用这两个对象。但是，它们却无法将其他值赋予first 或second 。因为final 声明为你买了相同的安全保险，而且这种格式更简洁明了。

还有另一种设计考虑，即你确实希望允许客户端程序员改变first 或second 所引用的对象。然而，采用以上的形式无疑是更安全的做法，这样的话，如果程序员想要使用具有不同元素的元组，就强制要求他们另外创建一个新的TwoTuple 对象。

我们可以利用继承机制实现长度更长的元组。从下面的例子中可以看到，增加类型参数是件很简单的事情：

泛型355622

为了使用元组，你只需定义一个长度适合的元组，将其作为方法的返回值，然后在return 语句中创建该元组，并返回即可。

由于有了泛型，你可以很容易地创建元组，令其返回一组任意类型的对象。而你所要做的，

只是编写表达式而已。通过ttsi.first = "there"语句的错误，我们可以看出，final 声明确实能够保护

public 元素，在对象被构造出来之后，声明为final 的元素便不能被再赋予其他值了。在上面的程序中，new 表达式确实有点罗嗦。本章稍后会介绍，如何利用泛型方法简化这样的表达式。练习3：(1) 使用泛型编写一个SixTuple 类，并测试它。练习4：(3) “泛型化”innerclasses/Sequence.java 类。

15.2.2 一个堆栈类

接下来我们看一个稍微复杂一点的例子：传统的下推堆栈。在第11章中，我们看到，这个堆栈是作为net.mindview.util.Stack 类，用一个LinkedList 实现的。在那个例子中，LinkedList 本身已经具备了创建堆栈所必需的方法，而Stack 可以通过两个泛型的类Stack和LinkedList的组合来创建。在那个示例中，我们可以看出，泛型类型也就是另一种类型罢了（稍候我们会356第15 章623

624

看到一些例外的情况）。

现在我们不用LinkedList ，来实现自己的内部链式存储机制。

内部类Node

也是一个泛型，它拥有自己的类型参数。这个例子使用了一个末端哨兵（end sentinel ）来判断堆栈何时为空。这个末端哨兵是在构造LinkedStack 时创建的。然后，每调用一次push()方法，就会创建一个Node对象，并将其链接到前一个Node对象。当你调用pop()方法时，总是返回top.item ，然后丢弃当前top 所指的Node，并将top 转移到下一个Node，除非你已经碰到了末端哨兵，这时候就不再移动top 了。如果已经到了末端，客户端程序还继续调用pop()方法，它只能得到null ，说明堆栈已经空了。

练习5：(2) 移除Node 类上的类型参数，并修改LinkedStack.java 的代码，证明内部类可以访问其外部类的类型参数。

15.2.3 RandomList

作为容器的另一个例子，假设我们需要一个持有特定类型对象的列表，每次调用其上的select()方法时，它可以随机地选取一个元素。如果我们希望以此构建一个可以应用于各种类型的对象的工具，就需要使用泛型：泛型357625

练习6：

(1) 使用RandomList

来处理两种额外的不同类型的元素，要区别于main()中已经用过的类型。

15.3 泛型接口泛型也可以应用于接口。例如生成器（generator ），这是一种专门负责创建对象的类。实际

上，这是工厂方法设计模式的一种应用。不过，当使用生成器创建新的对象时，它不需要任何参数，而工厂方法一般需要参数。也就是说，生成器无需额外的信息就知道如何创建新对象。

一般而言，一个生成器只定义一个方法，该方法用以产生新的对象。在这里，就是next()方法。我将它收录在我的标准工具类库中：

方法next()的返回类型是参数化的T 。正如你所见到的，接口使用泛型与类使用泛型没什么区别。

为了演示如何实现Generator 接口，我们还需要一些别的类。例如，Coffee 类层次结构如下：358第15 章626

627

现在，我们可以编写一个类，实现Generator

接口，它能够随机生成不同类型的Coffee 对象：

泛型359628

参数化的Generator 接口确保next()的返回值是参数的类型。CoffeeGenerator 同时还实现了Iterable 接口，所以它可以在循环语句中使用。不过，它还需要一个“末端哨兵”来判断何时停止，这正是第二个构造器的功能。

下面的类是Generator接口的另一个实现，它负责生成Fibonacci 数列：

虽然我们在

Fibonacci 类的里里外外使用的都是int 类型，但是其类型参数却是

Integer 。这个例子引出了

Java 泛型的一个局限性：基本类型无法作为类型参数。不过，Java SE5具备了自动打包和自动拆包的功能，可以很方便地在基本类型和其相应的包装器类型之间进行转换。通过这个例子中Fibonacci

类对int 的使用，我们已经看到了这种效果。

如果还想更进一步，编写一个实现了Iterable 的Fibonacci 生成器。我们的一个选择是重写这个类，令其实现Iterable 接口。不过，你并不是总能拥有源代码的控制权，并且，除非必须这么做，否则，我们也不愿意重写一个类。而且我们还有另一种选择，就是创建一个适配器（adapter ）来实现所需的接口，我们在前面介绍过这个设计模式。

有多种方法可以实现适配器。例如，可以通过继承来创建适配器类：

360第15 章629

630

如果要在循环语句中使用IterableFibonacci ，必须向

IterableFibonacci 的构造器提供一个边界值，然后hasNext()方法才能知道何时应该返回false 。练习7：(2) 使用组合代替继承，适配Fibonacci 使其成为Iterable 。

练习8：(2) 模仿Coffee 示例的样子，根据你喜爱的电影人物，创建一个StoryCharacters 的类层次结构，将它们划分为GoodGuys 和BadGuys 。再按照CoffeeGenerator 的形式，编写一个StoryCharacters 的生成器。

15.4 泛型方法

到目前为止，我们看到的泛型，都是应用于整个类上。但同样可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。

泛型方法使得该方法能够独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static 的方法而言，无法访问泛型类的类型参数，所以，如果static 方法需要使用泛型能力，就必须使其成为泛型方法。

要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：

GenericMethods 并不是参数化的，尽管这个类和其内部的方法可以被同时参数化，但是在这个例子中，只有方法f()拥有类型参数。这是由该方法的返回类型前面的类型参数列表指明的。

注意，当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型。这称为类型参数推断（type argument inference ）。因此，我们可以像调用普通方法一样调用f()，而且就好像是f()被无限次地重载过。它甚至可以接受GenericMethods 作为其类型参数。

如果调用f()时传入基本类型，自动打包机制就会介入其中，将基本类型的值包装为对应的对象。事实上，泛型方法与自动打包避免了许多以前我们不得不自己编写出来的代码。泛型361631632

练习9：(1) 修改GenericMethods.java 类，使f()可以接受三个类型各不相同的参数。

练习10：(1) 修改前一个练习，将方法f()的其中一个参数修改为非参数化的类型。

15.4.1 杠杆利用类型参数推断

人们对泛型有一个抱怨，使用泛型有时候需要向程序中加入更多的代码。考虑第11章中的holding/MapOfList.java 类，如果要创建一个持有List 的Map ，就要像下面这样：（本章稍后会介绍表达式中问号与

extends 的用法。）看到了吧，你在重复自己做过的事情，

编译器本来应该能够从泛型参数列表中的一个参数推断出另一个参数。唉，可惜的是，编译器暂时还做不到。然而，在泛型方法中，类型参数推断可以为我们简化一部分工作。例如，我们可以编写一个工具类，它包含各种各样的static 方法，专门用来创建各种常用的容器对象：

main()方法演示了如何使用这个工具类，类型参数推断避免了重复的泛型参数列表。它同

样可以应用于holding/MapOfList.java ：

对于类型参数推断而言，这是一个有趣的例子。不过，很难说它为我们带来了多少好处。362

第15 章633

如果某人阅读以上代码，他必须分析理解工具类New ，以及New 所隐含的功能。而这似乎与不使用New 时（具有重复的类型参数列表的定义）的工作效率差不多。这真够讽刺的，要知道，我们引入New 工具类的目的，正是为了使代码简单易读。不过，如果标准Java 类库要是能添加类似New.java 这样的工具类的话，我们还是应该使用这样的工具类。

类型推断只对赋值操作有效，其他时候并不起作用。如果你将一个泛型方法调用的结果（例如New.map()）作为参数，传递给另一个方法，这时编译器并不会执行类型推断。在这种情况下，编译器认为：调用泛型方法后，其返回值被赋给一个Object 类型的变量。下面的例子证明了这一点：

练习11：(1)

创建自己的若干个类来测试New.java ，并确保New

可以正确地与它们一起工作。显式的类型说明在泛型方法中，可以显式地指明类型，不过这种语法很少使用。要显式地指明类型，必须在点操作符与方法名之间插入尖括号，然后把类型置于尖括号内。如果是在定义该方法的类的内部，必须在点操作符之前使用this 关键字，如果是使用static 的方法，必须在点操作符之前加上类名。使用这种语法，可以解决LimitsOfInference.java 中的问题：

当然，这种语法抵消了New 类为我们带来的好处（即省去了大量的类型说明），不过，只有在编写非赋值语句时，我们才需要这样的额外说明。

练习12：(1) 使用显式的类型说明来重复前一个练习。

15.4.2 可变参数与泛型方法

泛型方法与可变参数列表能够很好地共存：泛型363634635

makeList()方法展示了与标准类库中

java.util.Arrays.asList()方法相同的功能。

15.4.3 用于Generator 的泛型方法利用生成器，我们可以很方便地填充一个Collection ，而泛型化这种操作是具有实际意义的：

请注意，fill()方法是如何透明地应用于Coffee 和

Integer 的容器和生成器。

练习13：(4) 重载fill()方法，使其参数与返回值的类型为Collection 的导出类：List 、Queue 和Set 。通过这种方式，我们就不会丢失容器的类型。能够在重载时区分List 和LinkedList 吗？15.4.4 一个通用的Generator

下面的程序可以为任何类构造一个Generator ，只要该类具有默认的构造器。为了减少类型声明，它提供了一个泛型方法，用以生成BasicGenerator ：

364第15 章636

这个类提供了一个基本实现，用以生成某个类的对象。这个类必需具备两个特点：（1

）它必须声明为public 。

（因为BasicGenerator 与要处理的类在不同的包中，所以该类必须声明为

public ，并且不只具有包内访问权限。）（2）它必须具备默认的构造器（无参数的构造器）。要创建这样的BasicGenerator 对象，只需调用create()方法，并传入想要生成的类型。泛型化的create()方法允许执行BasicGenerator.create(MyType.class)，而不必执行麻烦的new Basic-Generator(MyType.class)。

例如，下面是一个具有默认构造器的简单的类：

CountedObject 类能够记录下它创建了多少个CountedObject 实例，并通过toString()方法告诉我们其编号。

使用BasicGenerator ，你可以很容易地为CountedObject 创建一个Generator ：

可以看到，使用泛型方法创建Generator 对象，大大减少了我们要编写的代码。Java 泛型要求传入Class 对象，以便也可以在create()方法中用它进行类型推断。

练习14：(1) 修改BasicGeneratorDemo.java 类，使其显式地构造Generator （也就是不使用create()方法，而是使用显式的构造器）。泛型365637638

15.4.5 简化元组的使用

有了类型参数推断，再加上static 方法，我们可以重新编写之前看到的元组工具，使其成为更通用的工具类库。在这个类中，我们通过重载static 方法创建元组：

下面是修改后的TupleTest.java ，用来测试Tuple.java

：注意，方法f()返回一个参数化的

TwoTuple 对象，而f2()返回的是非参数化的TwoTuple 对象。366第15 章639

在这个例子中，编译器并没有关于f2()的警告信息，因为我们并没有将其返回值作为参数化对象使用。在某种意义上，它被“向上转型”为一个非参数化的TwoTuple 。然而，如果试图将f2()的返回值转型为参数化的TwoTuple ，编译器就会发出警告。

练习15：(1) 验证前面的陈述是否属实。

练习16：(2) 为Tuple.java 添加一个SixTuple ，并在TupleTest2.java 中进行测试。

15.4.6 一个Set 实用工具

作为泛型方法的另一个示例，我们看看如何用Set 来表达数学中的关系式。通过使用泛型方法，可以很方便地做到这一点，而且可以应用于多种类型：在前三个方法中，都将第一个参数Set

复制了一份，将Set 中的所有引用都存入一个新的HashSet 对象中，因此，我们并未直接修改参数中的Set 。返回的值是一个全新的Set 对象。

这四个方法表达了如下的数学集合操作：union()返回一个Set ，它将两个参数合并在一起；intersection()返回的Set 只包含两个参数共有的部分；difference()方法从superset 中移除subset 包含的元素；complement()返回的Set 包含除了交集之外的所有元素。下面提供了一个enum ，它包含各种水彩画的颜色。我们将用它来演示以上这些方法的功能和效果。

为了方便起见（可以直接使用enum 中的元素名），下面的示例以static 的方式引入Watercolors 。这个示例使用了EnumSet ，这是Java SE5中的新工具，用来从enum 直接创建Set 。（在第19章中，泛型367640641

我们会详细介绍EnumSet 。）在这里，我们向static 方法EnumSet.range()传入某个范围的第一个元素与最后一个元素，然后它将返回一个Set ，其中包含该范围内的所有元素：

我们可以从输出中看到各种关系运算的结果。

下面的示例使用

Sets.difference()打印出java.util 包中各种Collection

类与Map 类之间的方法差异：368

第15 章642

643

在第11章的“总结”中，我们使用了这个程序的输出结果。

练习17：(4) 研究JDK 文档中有关EnumSet 的部分，你会看到它定义了clone()方法。然而，在Sets.java 中，你却不能复制Set 接口中的引用。请试着修改Sets.java ，使其不但能接受一般的Set 接口，而且能直接接受EnumSet ，并使用clone()而不是创建新的HashSet 对象。

15.5 匿名内部类

泛型还可以应用于内部类以及匿名内部类。下面的示例使用匿名内部类实现了Generator 接口：泛型369644

Customer 和Teller 类都只有private 的构造器，这可以强制你必须使用

Generator 对象。Customer 有一个generator()方法，每次执行它都会生成一个新的Generator对象。我们其实不需要多个Generator 对象，Teller 就只创建了一个public 的generator 对象。在main()方法中可以看到，这两种创建Generator 的方式都在fill()中用到了。

由于Customer 中的generator()方法，以及Teller 中的Generator 对象都声明成了static 的，所以它们无法作为接口的一部分，因此无法用接口这种特定的惯用法来泛化这二者。尽管如此，它们在fill()方法中都工作得很好。

在第21章中，我们还会看到关于这个排队问题的另一个版本。

练习18：(3) 遵循BackTeller.java 的形式，创建一个Ocean 中BigFish 吃LittleFish 的例子。370第15 章645

646

15.6 构建复杂模型

泛型的一个重要好处是能够简单而安全地创建复杂的模型。例如，我们可以很容易地创建List 元组：尽管这看上去有些冗长（特别是迭代器的创建），但最终还是没有用过多的代码就得到了一

个相当强大的数据结构。下面是另一个示例，它展示了使用泛型类型来构建复杂模型是多么的简单。即使每个类都是作为一个构建块创建的，但是其整个还是包含许多部分。在本例中，构建的模型是一个零售店，它包含走廊、货架和商品：泛型371647