Java编程思想第4版[中文版](PDF格式)-第41部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！





8。2。1　　缺点：类型未知　　



使用Java　集合的“缺点”是在将对象置入一个集合时丢失了类型信息。之所以会发生这种情况，是由于当初　

编写集合时，那个集合的程序员根本不知道用户到底想把什么类型置入集合。若指示某个集合只允许特定的　

类型，会妨碍它成为一个“常规用途”的工具，为用户带来麻烦。为解决这个问题，集合实际容纳的是类型　

为Object　的一些对象的句柄。这种类型当然代表Java　中的所有对象，因为它是所有类的根。当然，也要注　

意这并不包括基本数据类型，因为它们并不是从“任何东西”继承来的。这是一个很好的方案，只是不适用　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　213　


…………………………………………………………Page　215……………………………………………………………

下述场合：　　

（1）　将一个对象句柄置入集合时，由于类型信息会被抛弃，所以任何类型的对象都可进入我们的集合——即　

便特别指示它只能容纳特定类型的对象。举个例子来说，虽然指示它只能容纳猫，但事实上任何人都可以把　

一条狗扔进来。　　

（2）　由于类型信息不复存在，所以集合能肯定的唯一事情就是自己容纳的是指向一个对象的句柄。正式使用　

它之前，必须对其进行造型，使其具有正确的类型。　　

　　

值得欣慰的是，Java　不允许人们滥用置入集合的对象。假如将一条狗扔进一个猫的集合，那么仍会将集合内　

的所有东西都看作猫，所以在使用那条狗时会得到一个“违例”错误。在同样的意义上，假若试图将一条狗　

的句柄“造型”到一只猫，那么运行期间仍会得到一个“违例”错误。　　

下面是个例子：　　

　　

//：　CatsAndDogs。java　　

//　Simple　collection　example　（Vector）　　

import　java。util。*；　　

　　

class　Cat　｛　　

　　private　int　catNumber；　　

　　Cat（int　i）　｛　　

　　　　catNumber　=　i；　　

　　｝　　

　　void　print（）　｛　　

　　　　System。out。println（〃Cat　#〃　＋　catNumber）；　　

　　｝　　

｝　　

　　

class　Dog　｛　　

　　private　int　dogNumber；　　

　　Dog（int　i）　｛　　

　　　　dogNumber　=　i；　　

　　｝　　

　　void　print（）　｛　　

　　　　System。out。println（〃Dog　#〃　＋　dogNumber）；　　

　　｝　　

｝　　

　　

public　class　CatsAndDogs　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Vector　cats　=　new　Vector（）；　　

　　　　for（int　i　=　0；　i　《　7；　i＋＋）　　

　　　　　　cats。addElement（new　Cat（i））；　　

　　　　//　Not　a　problem　to　add　a　dog　to　cats：　　

　　　　cats。addElement（new　Dog（7））；　　

　　　　for（int　i　=　0；　i　《　cats。size（）；　i＋＋）　　

　　　　　　（（Cat）cats。elementAt（i））。print（）；　　

　　　　//　Dog　is　detected　only　at　run…time　　

　　｝　　

｝　///：~　　

　　

可以看出，Vector　的使用是非常简单的：先创建一个，再用　addElement（）置入对象，以后用　elementAt（）取　

得那些对象（注意Vector　有一个　size（）方法，可使我们知道已添加了多少个元素，以便防止误超边界，造　

成违例错误）。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　214　


…………………………………………………………Page　216……………………………………………………………

Cat　和　Dog　类都非常浅显——除了都是“对象”之外，它们并无特别之处（倘若不明确指出从什么类继承，　

就默认为从　Object　继承。所以我们不仅能用Vector　方法将　Cat　对象置入这个集合，也能添加　Dog　对象，同　

时不会在编译期和运行期得到任何出错提示。用Vector　方法　elementAt（）获取原本认为是Cat　的对象时，实　

际获得的是指向一个Object　的句柄，必须将那个对象造型为Cat。随后，需要将整个表达式用括号封闭起　

来，在为Cat　调用print（）方法之前进行强制造型；否则就会出现一个语法错误。在运行期间，如果试图将　

Dog　对象造型为　Cat，就会得到一个违例。　　

这些处理的意义都非常深远。尽管显得有些麻烦，但却获得了安全上的保证。我们从此再难偶然造成一些隐　

藏得深的错误。若程序的一个部分（或几个部分）将对象插入一个集合，但我们只是通过一次违例在程序的　

某个部分发现一个错误的对象置入了集合，就必须找出插入错误的位置。当然，可通过检查代码达到这个目　

的，但这或许是最笨的调试工具。另一方面，我们可从一些标准化的集合类开始自己的编程。尽管它们在功　

能上存在一些不足，且显得有些笨拙，但却能保证没有隐藏的错误。　　

　　

1。　错误有时并不显露出来　　

在某些情况下，程序似乎正确地工作，不造型回我们原来的类型。第一种情况是相当特殊的：String　类从编　

译器获得了额外的帮助，使其能够正常工作。只要编译器期待的是一个String　对象，但它没有得到一个，就　

会自动调用在Object　里定义、并且能够由任何Java　类覆盖的　toString（）方法。这个方法能生成满足要求的　

String　对象，然后在我们需要的时候使用。　　

因此，为了让自己类的对象能显示出来，要做的全部事情就是覆盖toString（）方法，如下例所示：　　

　　

//：　WorksAnyway。java　　

//　In　special　cases；　things　just　seem　　

//　to　work　correctly。　　

import　java。util。*；　　

　　

class　Mouse　｛　　

　　private　int　mouseNumber；　　

　　Mouse（int　i）　｛　　

　　　　mouseNumber　=　i；　　

　　｝　　

　　//　Magic　method：　　

　　public　String　toString（）　｛　　

　　　　return　〃This　is　Mouse　#〃　＋　mouseNumber；　　

　　｝　　

　　void　print（String　msg）　｛　　

　　　　if（msg　！=　null）　System。out。println（msg）；　　

　　　　System。out。println（　　

　　　　　　〃Mouse　number　〃　＋　mouseNumber）；　　

　　｝　　

｝　　

　　

class　MouseTrap　｛　　

　　static　void　caughtYa（Object　m）　｛　　

　　　　Mouse　mouse　=　（Mouse）m；　//　Cast　from　Object　　

　　　　mouse。print（〃Caught　one！〃）；　　

　　｝　　

｝　　

　　

public　class　WorksAnyway　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Vector　mice　=　new　Vector（）；　　

　　　　for（int　i　=　0；　i　《　3；　i＋＋）　　

　　　　　　mice。addElement（new　Mouse（i））；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　215　


…………………………………………………………Page　217……………………………………………………………

　　　　for（int　i　=　0；　i　《　mice。size（）；　i＋＋）　｛　　

　　　　　　//　No　cast　necessary；　automatic　call　　

　　　　　　//　to　Object。toString（）：　　

　　　　　　System。out。println（　　

　　　　　　　　〃Free　mouse：　〃　＋　mice。elementAt（i））；　　

　　　　　　MouseTrap。caughtYa（mice。elementAt（i））；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

可在Mouse　里看到对toString（）的重定义代码。在main（）的第二个for　循环中，可发现下述语句：　　

　　

System。out。println（〃Free　mouse：　〃　＋　　

mice。elementAt（i））；　　

　　

在“＋”后，编译器预期看到的是一个String　对象。elementAt（）生成了一个　Object，所以为获得希望的　

String，编译器会默认调用toString（）。但不幸的是，只有针对String　才能得到象这样的结果；其他任何　

类型都不会进行这样的转换。　　

隐藏造型的第二种方法已在Mousetrap　里得到了应用。caughtYa（）方法接收的不是一个Mouse，而是一个　

Object。随后再将其造型为一个Mouse。当然，这样做是非常冒失的，因为通过接收一个　Object，任何东西　

都可以传递给方法。然而，假若造型不正确——如果我们传递了错误的类型——就会在运行期间得到一个违　

例错误。这当然没有在编译期进行检查好，但仍然能防止问题的发生。注意在使用这个方法时毋需进行造　

型：　　

MouseTrap。caughtYa（mice。elementAt（i））；　　

　　

2。　生成能自动判别类型的　Vector　　

大家或许不想放弃刚才那个问题。一个更“健壮”的方案是用　Vector　创建一个新类，使其只接收我们指定的　

类型，也只生成我们希望的类型。如下所示：　　

　　

//：　GopherVector。java　　

//　A　type…conscious　Vector　　

import　java。util。*；　　

　　

class　Gopher　｛　　

　　private　int　gopherNumber；　　

　　Gopher（int　i）　｛　　

　　　　gopherNumber　=　i；　　

　　｝　　

　　void　print（String　msg）　｛　　

　　　　if（msg　！=　null）　System。out。println（msg）；　　

　　　　System。out。println（　　

　　　　　　〃Gopher　number　〃　＋　gopherNumber）；　　

　　｝　　

｝　　

　　

class　GopherTrap　｛　　

　　static　void　caughtYa（Gopher　g）　｛　　

　　　　g。print（〃Caught　one！〃）；　　

　　｝　　

｝　　

　　

class　GopherVector　｛　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　216　


…………………………………………………………Page　218……………………………………………………………

　　private　Vector　v　=　new　Vector　（）；　　

　　public　void　addElement（Gopher　m）　｛　　

　　　　v。addElement（m）；　　

　　｝　　

　　public　Gopher　elementAt（int　index）　｛　　

　　　　return　（Gopher）v。elementAt（index）；　　

　　｝　　

　　public　int　size（）　｛　return　v。size（）；　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　GopherVector　gophers　=　new　GopherVector（）；　　

　　　　for（int　i　=　0；　i　《　3；　i＋＋）　　

　　　　　　gophers。addElement（new　Gopher（i））；　　

　　　　for（int　i　=　0；　i　《　gophers。size（）；　i＋＋）　　

　　　　　　GopherTrap。caughtYa（gophers。elementAt（i））；　　

　　｝　　

｝　///：~　　

　　

这前一个例子类似，只是新的　GopherVector　类有一个类型为Vector　的private　成员（从Vector　继承有些麻　

烦，理由稍后便知），而且方法也和Vector　类似。然而，它不会接收和产生普通Object，只对　Gopher　对象　

感兴趣。　　

由于GopherVector　只接收一个　Gopher　（地鼠），所以假如我们使用：　　

gophers。addElement（new　Pigeon（））；　　

就会在编译期间获得一条出错消息。采用这种方式，尽管从编码的角度看显得更令人沉闷，但可以立即判断　

出是否使用了正确的类型。　　

注意在使用　elementAt（）时不必进行造型——它肯定是一个Gopher。　　

　　

3。　参数化类型　　

这类问题并不是孤立的——我们许多时候都要在其他类型的基础上创建新类型。此时，在编译期间拥有特定　

的类型信息是非常有帮助的。这便是“参数化类型”的概念。在C＋＋中，它由语言通过“模板”获得了直接　

支持。至少，Java　保留了关键字　generic，期望有一天能够支持参数化类型。但我们现在无法确定这一天何　

时会来临。　　



8。3　枚举器（反复器）　　



在任何集合类中，必须通过某种方法在其中置入对象，再用另一种方法从中取得对象。毕竟，容纳各种各样　

的对象正是集合的首要任务。在Vector　中，addElement（）便是我们插入对象采用的方法，而　elementAt（）是　

提取对象的唯一方法。Vector　非常灵活，我们可在任何时候选择任何东西，并可使用不同的索引选择多个元　

素。　　

若从更高的角度看这个问题，就会发现它的一个缺陷：需要事先知道集合的准确类型，否则无法使用。乍看　

来，这一点似乎没什么关系。但假若最开始决定使用Vector，后来在程序中又决定（考虑执行效率的原因）　

改变成一个　List　（属于Java1。2　集合库的一部分），这时又该如何做呢？　　

可利用“反复器”（Iterator）的概念达到这个目的。它可以是一个对象，作用是遍历一系列对象，并选择　

那个序列中的每个对象，同时不让客户程序员知道或关注那个序列的基础结构。此外，我们通常认为反复器　

是一种“轻量级”对象；也就是说，创建它只需付出极少的代价。但也正是由于这个原因，我们常发现反复　

器存在一些似乎很奇怪的限制。例如，有些反复器只能朝一个方向移动。　　

Java　的Enumeration　（枚举，注释②）便是具有这些限制的一个反复器的例子。除下面这些外，不可再用它　

做其他任何事情：　　

（1）　用一个名为　elements（）的方法要求集合为我们提供一个　Enumeration。我们首次调用它的　nextElement（）　

时，这个Enumeration　会返回序列中的第一个元素。　　

（2）　用nextElement（）　获得下一个对象。　　

（3）　用hasMoreElements（）检查序列中是否还有更多的对象。　　

　　

②：“反复器”这个词在C＋＋和OOP　的其他地方是经常出现的，所以很难确定为什么Java　的开发者采用了这　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　217　


…………………………………………………………Page　219……………………………………………………………

样一个奇怪的名字。Java　1。2　的集合库修正了这个问题以及其他许多问题。　　

　　

只可用Enumeration　做这些事情，不能再有更多。它属于反复器一种简单的实现方式，但功能依然十分强　

大。为体会它的运作过程，让我们复习一下本章早些时候提到的CatsAndDogs。java　程序。在原始版本中，　

elementAt（）方法用于选择每一个元素，但在下述修订版中，可看到使用了一个“枚举”：　　

　　

//：　CatsAndDogs2。java　　

//　Simple　collection　with　Enumeration　　

import　java。util。*；　　

　　

class　Cat2　｛　　

　　private　int　catNumber；　　

　　Cat2（int　i）　｛　　

　　　　catNumber　=　i；　　

　　｝　　

　　void　print（）　｛　　

　　　　System。out。println（〃Cat　number　〃　＋catNumber）；　　

　　｝　　

｝　　

　　

class　Dog2　｛　　

　　private　int　dogNumber；　　

　　Dog2（int　i）　｛　　

　　　　dogNumber　=　i；　　

　　｝　　

　　void　print（）　｛　　

　　　　System。out。println（〃Dog　number　〃　＋dogNumber）；　　

　　｝　　

｝　　

　　

public　class　CatsAndDogs2　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Vector　cats　=　new　Vector（）；　　

　　　　for（int　i　=　0；　i　《　7；　i＋＋）　　

　　　　　　cats。addElement（new　Cat2（i））；　　

　　　　//　Not　a　problem　to　add　a　dog　to　cats：　　

　　　　cats。addElement（new　Dog2（7））；　　

　　　　Enumeration　e　=　cats。elements（）；　　

　　　　while（e。hasMoreElements（））　　

　　　　　　（（Cat2）e。nextElement（））。print（）；　　

　　　　//　Dog　is　detected　only　at　run…time　　

　　｝　　

｝　///：~　　

　　

我们看到唯一的改变就是最后几行。不再是：　　

　　

for（int　i　=　0；　i　《　cats。size（）；　i＋＋）　　

（（Cat）cats。elementAt（i））。print（）；　　

　　

而是用一个　Enumeration　遍历整个序列：　　

　　

while（e。hasMoreElements（））　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　218　


…………………………………………………………Page　220……………………………………………………………

（（Cat2）e。nextElement（））。print（）；　　

　　

使用Enumeration，我们不必关心集合中的元素数量。所有工作均由　hasMoreElements（）和nextElement（）自　

动照管了。　　

下面再看看另一个例子，让我们创建一个常规用途的打印方法：　　

　　

//：　HamsterMaze。java　　

//　Using　an　Enumeration　　

import　java。util。*；　　

　　

class　Hamster　｛　　

　　private　int　hamsterNumber；　　

　　Hamster（int　i）　｛　　

　　　　hamsterNumber　=　i；　　

　　｝　　

　　public　String　toString（）　｛　　

　　　　return　〃This　is　Hamster　#〃　＋　hamsterNumber；　　

　　｝　　

｝　　

　　

class　Printer　｛　　

　　static　void　printAll（Enumeration　e）　｛　　

　　　　while（e。hasMoreElements（））　　

　　　　　　System。out。println（　　

　　　　　　　　e。nextElement（）。toString（））；　　

　　｝　　

｝　　

　　

public　class　HamsterMaze　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Vector　v　=　new　Vector（）；　　

　　　　for（int　i　=　0；　i　《　3；　i＋＋）　　

　　　　　　v。addElement（new　Hamster（i））；　　

　　　　Printer。printAll（v。elements（））；　　

　　｝　　

｝　///：~　　

　　

仔细研究一下打印方法：　　

　　

static　void　printAll（Enumeration　e）　｛　　

　　while（e。hasMoreElements（））　　

　　　　System。out。println（　　

　　　　　　e。nextElement（）。toString（））；　　

｝　　

　　

注意其中没有与序列类型有关的信息。我们拥有的全部东西便是Enumeration。为了解有关序列的情况，一　

个Enumeration　便足够了：可取得下一个对象，亦可知道是否已抵达了末尾。取得一系列对象，然后在其中　

遍历，从而执行一个特定的操作——这是一个颇有价值的编程概念，本书许多地方都会沿用这一思路。　　

这个看似特殊的例子甚至可以更为通用，因为它使用了常规的　toString（）方法（之所以称为常规，是由于它　

属于Object　类的一部分）。下面是调用打印的另一个方法（尽管在效率上可能会差一些）：　　

System。out。println（〃〃　＋　e。nextElement（））；　　

它采用了封装到Java　内部的“自动转换成字串”技术。一旦编译器碰到一个字串，后面跟随一个“＋”，就　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　219　


…………………………………………………………Page　221……………………………………………………………

会希望后面又跟随一个字串，并自动调用　toString（）。在Java　1。1　中，第一个字串是不必要的；所有对象　

都会转换成字串。亦可对此执行一次造型，获得与调用toString（）同样的效果：　　

System。out。println（（String）e。nextElement（））　　

但我们想做的事情通常并不仅仅是调用Object　方法，所以会再度面临类型造型的问题。对于自己感兴趣的类　

型，必须假定自己已获得了一个Enumeration，然后将结果对象造型成为那种类型（若操作错误，会得到运　

行期违例）。　　



8。4　集合的类型　　



标准Java　1。0　和　1。1库配套提供了非常少的一系列集合类。但对于自己的大多数编程要求，它们基本上都能　

胜任。正如大家到本章末尾会看到的，Java　1。2　提供的是一套重新设计过的大型集合库。　　



8。4。1　Vector　　



Vector　的用法很简单，这已在前面的例子中得到了证明。尽管我们大多数时候只需用addElement（）插入对　

象，用　elementAt（）一次提取一个对象，并用elements（）获得对序列的一个“枚举”。但仍有其他一系列方　

法是非常有用的。同我们对于　Java　库惯常的做法一样，在这里并不使用或讲述所有这些方法。但请务必阅读　

相应的电子文档，对它们的工作有一个大概的认识。　　

　　

1。　崩溃Java　　

Java　标准集合里包含了　toString（）方法，所以它们能生成自己的　String　表达方式，包括它们容纳的对象。　

例如在Vector　中，toString（）会在Vector　的各个元素中步进和遍历，并为每个元素调用　toString（）。假定　

我们现在想打印出自己类的地址。看起来似乎简单地引用　this　即可（特别是C＋＋程序员有这样做的倾向）：　　

　　

//：　CrashJava。java　　

//　One　way　to　crash　Java　　

import　java。util。*；　　

　　

public　class　Cra