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

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


　　｝　　

　　public　String　getNext（）　｛　　

　　　　String　s　=　null；　　

　　　　try　｛　　

　　　　　　if（st。nextToken（）　！=　　

　　　　　　　　　　　　StreamTokenizer。TT_EOF）　｛　　

　　　　　　　　switch（st。ttype）　｛　　

　　　　　　　　　　case　StreamTokenizer。TT_EOL：　　

　　　　　　　　　　　　s　=　null；　　

　　　　　　　　　　　　break；　　

　　　　　　　　　　case　StreamTokenizer。TT_NUMBER：　　

　　　　　　　　　　　　s　=　Double。toString（st。nval）；　　

　　　　　　　　　　　　break；　　

　　　　　　　　　　case　StreamTokenizer。TT_WORD：　　

　　　　　　　　　　　　s　=　new　String（st。sval）；　　

　　　　　　　　　　　　break；　　

　　　　　　　　　　default：　//　single　character　in　ttype　　

　　　　　　　　　　　　s　=　String。valueOf（　（char）st。ttype）；　　

　　　　　　　　｝　　

　　　　　　｝　　

　　　　｝　catch（IOException　e）　｛　　

　　　　　　System。out。println（e）；　　

　　　　｝　　

　　　　return　s；　　

　　｝　　

　　public　static　String　strip（String　qualified）　｛　　

　　　　StripQualifiers　sq　=　　　

　　　　　　new　StripQualifiers（qualified）；　　

　　　　String　s　=　〃〃；　si；　　

　　　　while（（si　=　sq。getNext（））　！=　null）　｛　　

　　　　　　int　lastDot　=　si。lastIndexOf（'。'）；　　

　　　　　　if（lastDot　！=　…1）　　

　　　　　　　　si　=　si。substring（lastDot　＋　1）；　　

　　　　　　s　＋=　si；　　

　　　　｝　　

　　　　return　s；　　

　　｝　　

｝　///：~　　

　　

ShowMethodsClean　方法非常接近前一个ShowMethods，只是它取得了Method　和Constructor　数组，并将它们　

转换成单个　String　数组。随后，每个这样的　String　对象都在　StripQualifiers。Strip（）里“过”一遍，删　

除所有方法限定词。正如大家看到的那样，此时用到了StreamTokenizer　和String　来完成这个工作。　　

假如记不得一个类是否有一个特定的方法，而且不想在联机文档里逐步检查类结构，或者不知道那个类是否　

能对某个对象（如Color　对象）做某件事情，该工具便可节省大量编程时间。　　

第　17　章提供了这个程序的一个GUI　版本，可在自己写代码的时候运行它，以便快速查找需要的东西。　　



11。4　总结　　



利用RTTI　可根据一个匿名的基础类句柄调查出类型信息。但正是由于这个原因，新手们极易误用它，因为有　

些时候多形性方法便足够了。对那些以前习惯程序化编程的人来说，极易将他们的程序组织成一系列switch　

语句。他们可能用　RTTI　做到这一点，从而在代码开发和维护中损失多形性技术的重要价值。Java　的要求是　

让我们尽可能地采用多形性，只有在极特别的情况下才使用RTTI　。　　

但为了利用多形性，要求我们拥有对基础类定义的控制权，因为有些时候在程序范围之内，可能发现基础类　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　347　


…………………………………………………………Page　349……………………………………………………………

并未包括我们想要的方法。若基础类来自一个库，或者由别的什么东西控制着，RTTI　便是一种很好的解决方　

案：可继承一个新类型，然后添加自己的额外方法。在代码的其他地方，可以侦测自己的特定类型，并调用　

那个特殊的方法。这样做不会破坏多形性以及程序的扩展能力，因为新类型的添加不要求查找程序中的　

switch语句。但在需要新特性的主体中添加新代码时，就必须用　RTTI　侦测自己特定的类型。　　

从某个特定类的利益的角度出发，在基础类里加入一个特性后，可能意味着从那个基础类衍生的其他所有类　

都必须获得一些无意义的“鸡肋”。这使得接口变得含义模糊。若有人从那个基础类继承，且必须覆盖抽象　

方法，这一现象便会使他们陷入困扰。比如现在用一个类结构来表示乐器（Instrument）。假定我们想清洁　

管弦乐队中所有适当乐器的通气音栓（Spit　Valve），此时的一个办法是在基础类Instrument　中置入一个　

ClearSpitValve（）方法。但这样做会造成一个误区，因为它暗示着打击乐器和电子乐器中也有音栓。针对这　

种情况，RTTI　提供了一个更合理的解决方案，可将方法置入特定的类中（此时是Wind　，即“通气口”）——　

这样做是可行的。但事实上一种更合理的方案是将　prepareInstrument（）置入基础类中。初学者刚开始时往　

往看不到这一点，一般会认定自己必须使用RTTI　。　　

最后，RTTI　有时能解决效率问题。若代码大量运用了多形性，但其中的一个对象在执行效率上很有问题，便　

可用RTTI　找出那个类型，然后写一段适当的代码，改进其效率。　　



11。5　练习　　



（1）　写一个方法，向它传递一个对象，循环打印出对象层次结构中的所有类。　　

（2）　在ToyTest。java　中，将Toy　的默认构建器标记成注释信息，解释随之发生的事情。　　

（3）　新建一种类型的集合，令其使用一个Vector。捕获置入其中的第一个对象的类型，然后从那时起只允许　

用户插入那种类型的对象。　　

（4）　写一个程序，判断一个　Char　数组属于基本数据类型，还是一个真正的对象。　　

（5）　根据本章的说明，实现　clearSpitValve（）。　　

（6）　实现本章介绍的rotate（Shape）方法，令其检查是否已经旋转了一个圆（若已旋转，就不再执行旋转操　

作）。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　348　


…………………………………………………………Page　350……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　第　12　章　　传递和返回对象　　



　　

到目前为止，读者应对对象的“传递”有了一个较为深刻的认识，记住实际传递的只是一个句柄。　　

在许多程序设计语言中，我们可用语言的“普通”方式到处传递对象，而且大多数时候都不会遇到问题。但　

有些时候却不得不采取一些非常做法，使得情况突然变得稍微复杂起来（在C＋＋中则是变得非常复杂）。　

Java　亦不例外，我们十分有必要准确认识在对象传递和赋值时所发生的一切。这正是本章的宗旨。　　

若读者是从某些特殊的程序设计环境中转移过来的，那么一般都会问到：“Java　有指针吗？”有些人认为指　

针的操作很困难，而且十分危险，所以一厢情愿地认为它没有好处。同时由于Java　有如此好的口碑，所以应　

该很轻易地免除自己以前编程中的麻烦，其中不可能夹带有指针这样的“危险品”。然而准确地说，Java　是　

有指针的！事实上，Java　中每个对象（除基本数据类型以外）的标识符都属于指针的一种。但它们的使用受　

到了严格的限制和防范，不仅编译器对它们有“戒心”，运行期系统也不例外。或者换从另一个角度说，　

Java　有指针，但没有传统指针的麻烦。我曾一度将这种指针叫做“句柄”，但你可以把它想像成“安全指　

针”。和预备学校为学生提供的安全剪刀类似——除非特别有意，否则不会伤着自己，只不过有时要慢慢　

来，要习惯一些沉闷的工作。　　



12。1　传递句柄　　



将句柄传递进入一个方法时，指向的仍然是相同的对象。一个简单的实验可以证明这一点（若执行这个程序　

时有麻烦，请参考第3　章3。1。2　小节“赋值”）：　　

　　

//：　PassHandles。java　　

//　Passing　handles　around　　

package　c12；　　

　　

public　class　PassHandles　｛　　

　　static　void　f（PassHandles　h）　｛　　

　　　　System。out。println（〃h　inside　f（）：　〃　＋　h）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　PassHandles　p　=　new　PassHandles（）；　　

　　　　System。out。println（〃p　inside　main（）：　〃　＋　p）；　　

　　　　f（p）；　　

　　｝　　

｝　///：~　　

　　

toString　方法会在打印语句里自动调用，而　PassHandles　直接从　Object　继承，没有　toString　的重新定义。　

因此，这里会采用toString　的Object　版本，打印出对象的类，接着是那个对象所在的位置（不是句柄，而　

是对象的实际存储位置）。输出结果如下：　　

p　inside　main（）：　PassHandles@1653748　　

h　inside　f（）　：　PassHandles@1653748　　

可以看到，无论p　还是h　引用的都是同一个对象。这比复制一个新的PassHandles　对象有效多了，使我们能　

将一个参数发给一个方法。但这样做也带来了另一个重要的问题。　　



12。1。1　别名问题　　



　“别名”意味着多个句柄都试图指向同一个对象，就象前面的例子展示的那样。若有人向那个对象里写入一　

点什么东西，就会产生别名问题。若其他句柄的所有者不希望那个对象改变，恐怕就要失望了。这可用下面　

这个简单的例子说明：　　

　　

//：　Alias1。java　　

//　Aliasing　two　handles　to　one　object　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　349　


…………………………………………………………Page　351……………………………………………………………

　　

public　class　Alias1　｛　　

　　int　i；　　

　　Alias1（int　ii）　｛　i　=　ii；　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Alias1　x　=　new　Alias1（7）；　　

　　　　Alias1　y　=　x；　//　Assign　the　handle　　

　　　　System。out。println（〃x：　〃　＋　x。i）；　　

　　　　System。out。println（〃y：　〃　＋　y。i）；　　

　　　　System。out。println（〃Incrementing　x〃）；　　

　　　　x。i＋＋；　　

　　　　System。out。println（〃x：　〃　＋　x。i）；　　

　　　　System。out。println（〃y：　〃　＋　y。i）；　　

　　｝　　

｝　///：~　　

　　

对下面这行：　　

Alias1　y　=　x；　//　Assign　the　handle　　

它会新建一个Alias1　句柄，但不是把它分配给由new　创建的一个新鲜对象，而是分配给一个现有的句柄。所　

以句柄x　的内容——即对象　x　指向的地址——被分配给y，所以无论　x　还是y　都与相同的对象连接起来。这　

样一来，一旦x　的i　在下述语句中增值：　　

x。i＋＋；　　

y　的　i　值也必然受到影响。从最终的输出就可以看出：　　

x：　7　　

y：　7　　

Incrementing　x　　

x：　8　　

y：　8　　

此时最直接的一个解决办法就是干脆不这样做：不要有意将多个句柄指向同一个作用域内的同一个对象。这　

样做可使代码更易理解和调试。然而，一旦准备将句柄作为一个自变量或参数传递——这是Java　设想的正常　

方法——别名问题就会自动出现，因为创建的本地句柄可能修改“外部对象”（在方法作用域之外创建的对　

象）。下面是一个例子：　　

　　

//：　Alias2。java　　

//　Method　calls　implicitly　alias　their　　

//　arguments。　　

　　

public　class　Alias2　｛　　

　　int　i；　　

　　Alias2（int　ii）　｛　i　=　ii；　｝　　

　　static　void　f（Alias2　handle）　｛　　

　　　　handle。i＋＋；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Alias2　x　=　new　Alias2（7）；　　

　　　　System。out。println（〃x：　〃　＋　x。i）；　　

　　　　System。out。println（〃Calling　f（x）〃）；　　

　　　　f（x）；　　

　　　　System。out。println（〃x：　〃　＋　x。i）；　　

　　｝　　

｝　///：~　　

　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　350　


…………………………………………………………Page　352……………………………………………………………

输出如下：　　

x：　7　　

Calling　f（x）　　

x：　8　　

　　

方法改变了自己的参数——外部对象。一旦遇到这种情况，必须判断它是否合理，用户是否愿意这样，以及　

是不是会造成问题。　　

通常，我们调用一个方法是为了产生返回值，或者用它改变为其调用方法的那个对象的状态（方法其实就是　

我们向那个对象“发一条消息”的方式）。很少需要调用一个方法来处理它的参数；这叫作利用方法的“副　

作用”（Side　Effect）。所以倘若创建一个会修改自己参数的方法，必须向用户明确地指出这一情况，并警　

告使用那个方法可能会有的后果以及它的潜在威胁。由于存在这些混淆和缺陷，所以应该尽量避免改变参　

数。　　

若需在一个方法调用期间修改一个参数，且不打算修改外部参数，就应在自己的方法内部制作一个副本，从　

而保护那个参数。本章的大多数内容都是围绕这个问题展开的。　　



12。2　制作本地副本　　



稍微总结一下：Java　中的所有自变量或参数传递都是通过传递句柄进行的。也就是说，当我们传递“一个对　

象”时，实际传递的只是指向位于方法外部的那个对象的“一个句柄”。所以一旦要对那个句柄进行任何修　

改，便相当于修改外部对象。此外：　　

■参数传递过程中会自动产生别名问题　　

■不存在本地对象，只有本地句柄　　

■句柄有自己的作用域，而对象没有　　

■对象的“存在时间”在Java　里不是个问题　　

■没有语言上的支持（如常量）可防止对象被修改（以避免别名的副作用）　　

若只是从对象中读取信息，而不修改它，传递句柄便是自变量传递中最有效的一种形式。这种做非常恰当；　

默认的方法一般也是最有效的方法。然而，有时仍需将对象当作“本地的”对待，使我们作出的改变只影响　

一个本地副本，不会对外面的对象造成影响。许多程序设计语言都支持在方法内自动生成外部对象的一个本　

地副本（注释①）。尽管Java　不具备这种能力，但允许我们达到同样的效果。　　

　　

①：在　C　语言中，通常控制的是少量数据位，默认操作是按值传递。C＋＋也必须遵照这一形式，但按值传递对　

象并非肯定是一种有效的方式。此外，在C＋＋中用于支持按值传递的代码也较难编写，是件让人头痛的事　

情。　　



12。2。1　按值传递　　



首先要解决术语的问题，最适合“按值传递”的看起来是自变量。“按值传递”以及它的含义取决于如何理　

解程序的运行方式。最常见的意思是获得要传递的任何东西的一个本地副本，但这里真正的问题是如何看待　

自己准备传递的东西。对于“按值传递”的含义，目前存在两种存在明显区别的见解：　　

（1）　Java按值传递任何东西。若将基本数据类型传递进入一个方法，会明确得到基本数据类型的一个副本。　

但若将一个句柄传递进入方法，得到的是句柄的副本。所以人们认为“一切”都按值传递。当然，这种说法　

也有一个前提：句柄肯定也会被传递。但　Java　的设计方案似乎有些超前，允许我们忽略（大多数时