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

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


　　boolean　end（）；　　

　　Object　current（）；　　

　　void　next（）；　　

｝　　

　　

public　class　Sequence　｛　　

　　private　Object＇＇　o；　　

　　private　int　next　=　0；　　

　　public　Sequence（int　size）　｛　　

　　　　o　=　new　Object＇size＇；　　

　　｝　　

　　public　void　add（Object　x）　｛　　

　　　　if（next　《　o。length）　｛　　

　　　　　　o＇next＇　=　x；　　

　　　　　　next＋＋；　　

　　　　｝　　

　　｝　　

　　private　class　SSelector　implements　Selector　｛　　

　　　　int　i　=　0；　　

　　　　public　boolean　end（）　｛　　

　　　　　　return　i　==　o。length；　　

　　　　｝　　

　　　　public　Object　current（）　｛　　

　　　　　　return　o＇i＇；　　

　　　　｝　　

　　　　public　void　next（）　｛　　

　　　　　　if（i　《　o。length）　i＋＋；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　186　


…………………………………………………………Page　188……………………………………………………………

　　　　｝　　

　　｝　　

　　public　Selector　getSelector（）　｛　　

　　　　return　new　SSelector（）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Sequence　s　=　new　Sequence（10）；　　

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

　　　　　　s。add（Integer。toString（i））；　　

　　　　Selector　sl　=　s。getSelector（）；　　　　　　

　　　　while（！sl。end（））　｛　　

　　　　　　System。out。println（（String）sl。current（））；　　

　　　　　　sl。next（）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

②：这与C＋＋　“嵌套类”的设计颇有不同，后者只是一种单纯的名字隐藏机制。在C＋＋中，没有指向一个封装　

对象的链接，也不存在默认的访问权限。　　

　　

其中，Sequence　只是一个大小固定的对象数组，有一个类将其封装在内部。我们调用add（），以便将一个新　

对象添加到　Sequence　末尾（如果还有地方的话）。为了取得Sequence　中的每一个对象，要使用一个名为　

Selector　的接口，它使我们能够知道自己是否位于最末尾（end（）），能观看当前对象（current（）　　

Object），以及能够移至　Sequence　内的下一个对象（next（）　Object　）。由于Selector　是一个接口，所以其　

他许多类都能用它们自己的方式实现接口，而且许多方法都能将接口作为一个自变量使用，从而创建一般的　

代码。　　

在这里，SSelector　是一个私有类，它提供了　Selector　功能。在main（）中，大家可看到Sequence　的创建过　

程，在它后面是一系列字串对象的添加。随后，通过对getSelector（）的一个调用生成一个Selector　。并用　

它在Sequence　中移动，同时选择每一个项目。　　

从表面看，SSelector　似乎只是另一个内部类。但不要被表面现象迷惑。请注意观察　end（），current（）以及　

next（），它们每个方法都引用了o。o　是个不属于　SSelector　一部分的句柄，而是位于封装类里的一个　

private　字段。然而，内部类可以从封装类访问方法与字段，就象已经拥有了它们一样。这一特征对我们来　

说是非常方便的，就象在上面的例子中看到的那样。　　

因此，我们现在知道一个内部类可以访问封装类的成员。这是如何实现的呢？内部类必须拥有对封装类的特　

定对象的一个引用，而封装类的作用就是创建这个内部类。随后，当我们引用封装类的一个成员时，就利用　

那个（隐藏）的引用来选择那个成员。幸运的是，编译器会帮助我们照管所有这些细节。但我们现在也可以　

理解内部类的一个对象只能与封装类的一个对象联合创建。在这个创建过程中，要求对封装类对象的句柄进　

行初始化。若不能访问那个句柄，编译器就会报错。进行所有这些操作的时候，大多数时候都不要求程序员　

的任何介入。　　



7。6。4　static　内部类　　



为正确理解　static在应用于内部类时的含义，必须记住内部类的对象默认持有创建它的那个封装类的一个对　

象的句柄。然而，假如我们说一个内部类是static　的，这种说法却是不成立的。static　内部类意味着：　　

（1）　为创建一个　static　内部类的对象，我们不需要一个外部类对象。　　

（2）　不能从　static　内部类的一个对象中访问一个外部类对象。　　

但在存在一些限制：由于　static　成员只能位于一个类的外部级别，所以内部类不可拥有static　数据或　

static　内部类。　　

倘若为了创建内部类的对象而不需要创建外部类的一个对象，那么可将所有东西都设为static。为了能正常　

工作，同时也必须将内部类设为static。如下所示：　　

　　

//：　Parcel10。java　　

//　Static　inner　classes　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　187　


…………………………………………………………Page　189……………………………………………………………

package　c07。parcel10；　　

　　

abstract　class　Contents　｛　　

　　abstract　public　int　value（）；　　

｝　　

　　

interface　Destination　｛　　

　　String　readLabel（）；　　

｝　　

　　

public　class　Parcel10　｛　　

　　private　static　class　PContents　　　

　　extends　Contents　｛　　

　　　　private　int　i　=　11；　　

　　　　public　int　value（）　｛　return　i；　｝　　

　　｝　　

　　protected　static　class　PDestination　　

　　　　　　implements　Destination　｛　　

　　　　private　String　label；　　

　　　　private　PDestination（String　whereTo）　｛　　

　　　　　　label　=　whereTo；　　

　　　　｝　　

　　　　public　String　readLabel（）　｛　return　label；　｝　　

　　｝　　

　　public　static　Destination　dest（String　s）　｛　　

　　　　return　new　PDestination（s）；　　

　　｝　　

　　public　static　Contents　cont（）　｛　　

　　　　return　new　PContents（）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Contents　c　=　cont（）；　　

　　　　Destination　d　=　dest（〃Tanzania〃）；　　

　　｝　　

｝　///：~　　

　　

在main（）中，我们不需要Parcel10　的对象；相反，我们用常规的语法来选择一个　static　成员，以便调用将　

句柄返回Contents　和　Destination　的方法。　　

通常，我们不在一个接口里设置任何代码，但　static　内部类可以成为接口的一部分。由于类是“静态”的，　

所以它不会违反接口的规则——static　内部类只位于接口的命名空间内部：　　

　　

//：　IInterface。java　　

//　Static　inner　classes　inside　interfaces　　

　　

interface　IInterface　｛　　

　　static　class　Inner　｛　　

　　　　int　i；　j；　k；　　

　　　　public　Inner（）　｛｝　　

　　　　void　f（）　｛｝　　

　　｝　　

｝　///：~　　

　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　188　


…………………………………………………………Page　190……………………………………………………………

在本书早些时候，我建议大家在每个类里都设置一个main（），将其作为那个类的测试床使用。这样做的一个　

缺点就是额外代码的数量太多。若不愿如此，可考虑用一个　static　内部类容纳自己的测试代码。如下所示：　　

　　

//：　TestBed。java　　

//　Putting　test　code　in　a　static　inner　class　　

　　

class　TestBed　｛　　

　　TestBed（）　｛｝　　

　　void　f（）　｛　System。out。println（〃f（）〃）；　｝　　

　　public　static　class　Tester　｛　　

　　　　public　static　void　main（String＇＇　args）　｛　　

　　　　　　TestBed　t　=　new　TestBed（）；　　

　　　　　　t。f（）；　　

　　　　｝　　

　　｝　　

｝　///：~　　

　　

这样便生成一个独立的、名为　TestBedTester　的类（为运行程序，请使用“java　TestBedTester　”命　

令）。可将这个类用于测试，但不需在自己的最终发行版本中包含它。　　



7。6。5　　引用外部类对象　　



若想生成外部类对象的句柄，就要用一个点号以及一个this　来命名外部类。举个例子来说，在　

Sequence。SSelector　类中，它的所有方法都能产生外部类Sequence　的存储句柄，方法是采用Sequence。this　

的形式。结果获得的句柄会自动具备正确的类型（这会在编译期间检查并核实，所以不会出现运行期的开　

销）。　　

有些时候，我们想告诉其他某些对象创建它某个内部类的一个对象。为达到这个目的，必须在　new　表达式中　

提供指向其他外部类对象的一个句柄，就象下面这样：　　

　　

//：　Parcel11。java　　

//　Creating　inner　classes　　

package　c07。parcel11；　　

　　

public　class　Parcel11　｛　　

　　class　Contents　｛　　

　　　　private　int　i　=　11；　　

　　　　public　int　value（）　｛　return　i；　｝　　

　　｝　　

　　class　Destination　｛　　

　　　　private　String　label；　　

　　　　Destination（String　whereTo）　｛　　

　　　　　　label　=　whereTo；　　

　　　　｝　　

　　　　String　readLabel（）　｛　return　label；　｝　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Parcel11　p　=　new　Parcel11（）；　　

　　　　//　Must　use　instance　of　outer　class　　

　　　　//　to　create　an　in　stances　of　the　inner　class：　　

　　　　Parcel11。Contents　c　=　p。new　Contents（）；　　

　　　　Parcel11。Destination　d　=　　

　　　　　　p。new　Destination（〃Tanzania〃）；　　

　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　189　


…………………………………………………………Page　191……………………………………………………………

｝　///：~　　

　　

为直接创建内部类的一个对象，不能象大家或许猜想的那样——采用相同的形式，并引用外部类名　

Parcel11　。此时，必须利用外部类的一个对象生成内部类的一个对象：　　

Parcel11。Contents　c　=　p。new　Contents（）；　　

因此，除非已拥有外部类的一个对象，否则不可能创建内部类的一个对象。这是由于内部类的对象已同创建　

它的外部类的对象“默默”地连接到一起。然而，如果生成一个static　内部类，就不需要指向外部类对象的　

一个句柄。　　



7。6。6　　从内部类继承　　



由于内部类构建器必须同封装类对象的一个句柄联系到一起，所以从一个内部类继承的时候，情况会稍微变　

得有些复杂。这儿的问题是封装类的“秘密”句柄必须获得初始化，而且在衍生类中不再有一个默认的对象　

可以连接。解决这个问题的办法是采用一种特殊的语法，明确建立这种关联：　　

　　

//：　InheritInner。java　　

//　Inheriting　an　inner　class　　

　　

class　WithInner　｛　　

　　class　Inner　｛｝　　

｝　　

　　

public　class　InheritInner　　　

　　　　extends　WithInner。Inner　　｛　　

　　//！　InheritInner（）　｛｝　//　Won't　pile　　

　　InheritInner（WithInner　wi）　｛　　

　　　　wi。super（）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　WithInner　wi　=　new　WithInner（）；　　

　　　　InheritInner　ii　=　new　InheritInner（wi）；　　

　　｝　　

｝　///：~　　

　　

从中可以看到，InheritInner　只对内部类进行了扩展，没有扩展外部类。但在需要创建一个构建器的时候，　

默认对象已经没有意义，我们不能只是传递封装对象的一个句柄。此外，必须在构建器中采用下述语法：　　

enclosingClassHandle。super（）；　　

它提供了必要的句柄，以便程序正确编译。　　



7。6。7　　内部类可以覆盖吗？　　



若创建一个内部类，然后从封装类继承，并重新定义内部类，那么会出现什么情况呢？也就是说，我们有可　

能覆盖一个内部类吗？这看起来似乎是一个非常有用的概念，但“覆盖”一个内部类——好象它是外部类的　

另一个方法——这一概念实际不能做任何事情：　　

　　

//：　BigEgg。java　　

//　An　inner　class　cannot　be　overriden　　　

//　like　a　method　　

　　

class　Egg　｛　　

　　protected　class　Yolk　｛　　

　　　　public　Yolk（）　｛　　

　　　　　　System。out。println（〃Egg。Yolk（）〃）；　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　190　


…………………………………………………………Page　192……………………………………………………………

　　　　｝　　

　　｝　　

　　private　Yolk　y；　　

　　public　Egg（）　｛　　

　　　　System。out。println（〃New　Egg（）〃）；　　

　　　　y　=　new　Yolk（）；　　

　　｝　　

｝　　

　　

public　class　BigEgg　extends　Egg　｛　　

　　public　class　Yolk　｛　　

　　　　public　Yolk（）　｛　　

　　　　　　System。out。println（〃BigEgg。Yolk（）〃）；　　

　　　　｝　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　new　BigEgg（）；　　

　　｝　　

｝　///：~　　

　　

默认构建器是由编译器自动合成的，而且会调用基础类的默认构建器。大家或许会认为由于准备创建一个　

BigEgg，所以会使用Yolk　的“被覆盖”版本。但实际情况并非如此。输出如下：　　

New　Egg（）　　

Egg。Yolk（）　　

这个例子简单地揭示出当我们从外部类继承的时候，没有任何额外的内部类继续下去。然而，仍然有可能　

　“明确”地从内部类继承：　　

　　

//：　BigEgg2。java　　

//　Proper　inheritance　of　an　inner　class　　

　　

class　Egg2　｛　　

　　protected　class　Yolk　｛　　

　　　　public　Yolk（）　｛　　

　　　　　　System。out。println（〃Egg2。Yolk（）〃）；　　

　　　　｝　　

　　　　public　void　f（）　｛　　

　　　　　　System。out。println（〃Egg2。Yolk。f（）〃）；　　

　　　　｝　　

　　｝　　

　　private　Yolk　y　=　new　Yolk（）；　　

　　public　Egg2（）　｛　　

　　　　System。out。println（〃New　Egg2（）〃）；　　

　　｝　　

　　public　void　insertYolk（Yolk　yy）　｛　y　=　yy；　｝　　

　　public　void　g（）　｛　y。f（）；　｝　　

｝　　

　　

public　class　BigEgg2　extends　Egg2　｛　　

　　public　class　Yolk　extends　Egg2。Yolk　｛　　

　　　　public　Yolk（）　｛　　

　　　　　　System。out。println（〃BigEgg2。Yolk（）〃）；　　

　　　　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　191　


…………………………………………………………Page　193……………………………