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

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


后，并不会强迫我们将它的所有方法都同时变成抽象。下面是它看起来的样子：　　

　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　169　


…………………………………………………………Page　171……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　

下面是我们修改过的“管弦”乐器例子，其中采用了抽象类以及方法：　　

　　

//：　Music4。java　　

//　Abstract　classes　and　methods　　

import　java。util。*；　　

　　

abstract　class　Instrument4　｛　　

　　int　i；　//　storage　allocated　for　each　　

　　public　abstract　void　play（）；　　

　　public　String　what（）　｛　　

　　　　return　〃Instrument4〃；　　

　　｝　　

　　public　abstract　void　adjust（）；　　

｝　　

　　

class　Wind4　extends　Instrument4　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Wind4。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Wind4〃；　｝　　

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Percussion4　extends　Instrument4　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Percussion4。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Percussion4〃；　｝　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　170　


…………………………………………………………Page　172……………………………………………………………

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Stringed4　extends　Instrument4　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Stringed4。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Stringed4〃；　｝　　

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Brass4　extends　Wind4　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Brass4。play（）〃）；　　

　　｝　　

　　public　void　adjust（）　｛　　　

　　　　System。out。println（〃Brass4。adjust（）〃）；　　

　　｝　　

｝　　

　　

class　Woodwind4　extends　Wind4　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Woodwind4。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Woodwind4〃；　｝　　

｝　　

　　

public　class　Music4　｛　　

　　//　Doesn't　care　about　type；　so　new　types　　

　　//　added　to　the　system　still　work　right：　　

　　static　void　tune（Instrument4　i）　｛　　

　　　　//　。。。　　

　　　　i。play（）；　　

　　｝　　

　　static　void　tuneAll（Instrument4＇＇　e）　｛　　

　　　　for（int　i　=　0；　i　《　e。length；　i＋＋）　　

　　　　　　tune（e＇i＇）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Instrument4＇＇　orchestra　=　new　Instrument4＇5＇；　　

　　　　int　i　=　0；　　

　　　　//　Upcasting　during　addition　to　the　array：　　

　　　　orchestra＇i＋＋＇　=　new　Wind4（）；　　

　　　　orchestra＇i＋＋＇　=　new　Percussion4（）；　　

　　　　orchestra＇i＋＋＇　=　new　Stringed4（）；　　

　　　　orchestra＇i＋＋＇　=　new　Brass4（）；　　

　　　　orchestra＇i＋＋＇　=　new　Woodwind4（）；　　

　　　　tuneAll（orchestra）；　　

　　｝　　

｝　///：~　　

　　

可以看出，除基础类以外，实际并没有进行什么改变。　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　171　


…………………………………………………………Page　173……………………………………………………………

创建抽象类和方法有时对我们非常有用，因为它们使一个类的抽象变成明显的事实，可明确告诉用户和编译　

器自己打算如何用它。　　



7。5　接口　　



　“interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创　

建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也包含了基本数　

据类型的数据成员，但它们都默认为　static　和final。接口只提供一种形式，并不提供实施的细节。　　

接口这样描述自己：“对于实现我的所有类，看起来都应该象我现在这个样子”。因此，采用了一个特定接　

口的所有代码都知道对于那个接口可能会调用什么方法。这便是接口的全部含义。所以我们常把接口用于建　

立类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol　”（协议）的关键　

字，它做的便是与接口相同的事情。　　

为创建一个接口，请使用　interface　关键字，而不要用　class。与类相似，我们可在　interface关键字的前　

面增加一个　public　关键字（但只有接口定义于同名的一个文件内）；或者将其省略，营造一种“友好的”状　

态。　　

为了生成与一个特定的接口（或一组接口）相符的类，要使用　implements　（实现）关键字。我们要表达的意　

思是“接口看起来就象那个样子，这儿是它具体的工作细节”。除这些之外，我们其他的工作都与继承极为　

相似。下面是乐器例子的示意图：　　

　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　

具体实现了一个接口以后，就获得了一个普通的类，可用标准方式对其进行扩展。　　

可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义，它们也会默认为　public。所以　

在实现一个接口的时候，来自接口的方法必须定义成public。否则的话，它们会默认为“友好的”，而且会　

限制我们在继承过程中对一个方法的访问——Java　编译器不允许我们那样做。　　

在　Instrument　例子的修改版本中，大家可明确地看出这一点。注意接口中的每个方法都严格地是一个声明，　

它是编译器唯一允许的。除此以外，Instrument5　中没有一个方法被声明为public，但它们都会自动获得　

public　属性。如下所示：　　

　　

//：　Music5。java　　

//　Interfaces　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　172　


…………………………………………………………Page　174……………………………………………………………

import　java。util。*；　　

　　

interface　Instrument5　｛　　

　　//　pile…time　constant：　　

　　int　i　=　5；　//　static　&　final　　

　　//　Cannot　have　method　definitions：　　

　　void　play（）；　//　Automatically　public　　

　　String　what（）；　　

　　void　adjust（）；　　

｝　　

　　

class　Wind5　implements　Instrument5　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Wind5。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Wind5〃；　｝　　

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Percussion5　implements　Instrument5　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Percussion5。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Percussion5〃；　｝　　

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Stringed5　implements　Instrument5　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Stringed5。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Stringed5〃；　｝　　

　　public　void　adjust（）　｛｝　　

｝　　

　　

class　Brass5　extends　Wind5　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Brass5。play（）〃）；　　

　　｝　　

　　public　void　adjust（）　｛　　　

　　　　System。out。println（〃Brass5。adjust（）〃）；　　

　　｝　　

｝　　

　　

class　Woodwind5　extends　Wind5　｛　　

　　public　void　play（）　｛　　

　　　　System。out。println（〃Woodwind5。play（）〃）；　　

　　｝　　

　　public　String　what（）　｛　return　〃Woodwind5〃；　｝　　

｝　　

　　

public　class　Music5　｛　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　173　


…………………………………………………………Page　175……………………………………………………………

　　//　Doesn't　care　about　type；　so　new　types　　

　　//　added　to　the　system　still　work　right：　　

　　static　void　tune（Instrument5　i）　｛　　

　　　　//　。。。　　

　　　　i。play（）；　　

　　｝　　

　　static　void　tuneAll（Instrument5＇＇　e）　｛　　

　　　　for（int　i　=　0；　i　《　e。length；　i＋＋）　　

　　　　　　tune（e＇i＇）；　　

　　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Instrument5＇＇　orchestra　=　new　Instrument5＇5＇；　　

　　　　int　i　=　0；　　

　　　　//　Upcasting　during　addition　to　the　array：　　

　　　　orchestra＇i＋＋＇　=　new　Wind5（）；　　

　　　　orchestra＇i＋＋＇　=　new　Percussion5（）；　　

　　　　orchestra＇i＋＋＇　=　new　Stringed5（）；　　

　　　　orchestra＇i＋＋＇　=　new　Brass5（）；　　

　　　　orchestra＇i＋＋＇　=　new　Woodwind5（）；　　

　　　　tuneAll（orchestra）；　　

　　｝　　

｝　///：~　　

　　

代码剩余的部分按相同的方式工作。我们可以自由决定上溯造型到一个名为　Instrument5　的“普通”类，一　

个名为　Instrument5　的“抽象”类，或者一个名为　Instrument5　的“接口”。所有行为都是相同的。事实　

上，我们在　tune（）方法中可以发现没有任何证据显示　Instrument5　到底是个“普通”类、“抽象”类还是一　

个“接口”。这是做是故意的：每种方法都使程序员能对对象的创建与使用进行不同的控制。　　



7。5。1　Java　的“多重继承”　　



接口只是比抽象类“更纯”的一种形式。它的用途并不止那些。由于接口根本没有具体的实施细节——也就　

是说，没有与存储空间与“接口”关联在一起——所以没有任何办法可以防止多个接口合并到一起。这一点　

是至关重要的，因为我们经常都需要表达这样一个意思：“x　从属于　a，也从属于　b，也从属于　c”。在C＋＋　

中，将多个类合并到一起的行动称作“多重继承”，而且操作较为不便，因为每个类都可能有一套自己的实　

施细节。在　Java　中，我们可采取同样的行动，但只有其中一个类拥有具体的实施细节。所以在合并多个接口　

的时候，C＋＋的问题不会在Java　中重演。如下所示：　　

　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　

在一个衍生类中，我们并不一定要拥有一个抽象或具体（没有抽象方法）的基础类。如果确实想从一个非接　

口继承，那么只能从一个继承。剩余的所有基本元素都必须是“接口”。我们将所有接口名置于　implements　

关键字的后面，并用逗号分隔它们。可根据需要使用多个接口，而且每个接口都会成为一个独立的类型，可　

对其进行上溯造型。下面这个例子展示了一个“具体”类同几个接口合并的情况，它最终生成了一个新类：　　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　174　


…………………………………………………………Page　176……………………………………………………………

　　

//：　Adventure。java　　

//　Multiple　interfaces　　

import　java。util。*；　　

　　

interface　CanFight　｛　　

　　void　fight（）；　　

｝　　

　　

interface　CanSwim　｛　　

　　void　swim（）；　　

｝　　

　　

interface　CanFly　｛　　

　　void　fly（）；　　

｝　　

　　

class　ActionCharacter　｛　　

　　public　void　fight（）　｛｝　　

｝　　

　　

class　Hero　extends　ActionCharacter　　　

　　　　implements　CanFight；　CanSwim；　CanFly　｛　　

　　public　void　swim（）　｛｝　　

　　public　void　fly（）　｛｝　　

｝　　

　　

public　class　Adventure　｛　　

　　static　void　t（CanFight　x）　｛　x。fight（）；　｝　　

　　static　void　u（CanSwim　x）　｛　x。swim（）；　｝　　

　　static　void　v（CanFly　x）　｛　x。fly（）；　｝　　

　　static　void　w（ActionCharacter　x）　｛　x。fight（）；　｝　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Hero　i　=　new　Hero（）；　　

　　　　t（i）；　//　Treat　it　as　a　CanFight　　

　　　　u（i）；　//　Treat　it　as　a　CanSwim　　

　　　　v（i）；　//　Treat　it　as　a　CanFly　　

　　　　w（i）；　//　Treat　it　as　an　ActionCharacter　　

　　｝　　

｝　///：~　　

　　

从中可以看到，Hero　将具体类ActionCharacter　同接口CanFight，CanSwim　以及CanFly　合并起来。按这种　

形式合并一个具体类与接口的时候，具体类必须首先出现，然后才是接口（否则编译器会报错）。　　

请注意　fight（）的签名在CanFight　接口与　ActionCharacter　类中是相同的，而且没有在Hero　中为fight（）提　

供一个具体的定义。接口的规则是：我们可以从它继承（稍后就会看到），但这样得到的将是另一个接口。　

如果想创建新类型的一个对象，它就必须是已提供所有定义的一个类。尽管Hero　没有为　fight（）明确地提供　

一个定义，但定义是随同ActionCharacter　来的，所以这个定义会自动提供，我们可以创建Hero　的对象。　　

在类Adventure　中，我们可看到共有四个方法，它们将不同的接口和具体类作为自己的自变量使用。创建一　

个Hero　对象后，它可以传递给这些方法中的任何一个。这意味着它们会依次上溯造型到每一个接口。由于接　

口是用Java　设计的，所以这样做不会有任何问题，而且程序员不必对此加以任何特别的关注。　　

注意上述例子已向我们揭示了接口最关键的作用，也是使用接口最重要的一个原因：能上溯造型至多个基础　

类。使用接口的第二个原因与使用抽象基础类的原因是一样的：防止客户程序员制作这个类的一个对象，以　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　175　


…………………………………………………………Page　177……………………………………………………………

及规定它仅仅是一个接口。这样便带来了一个问题：到底应该使用一个接口还是一个抽象类呢？若使用接　

口，我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者成员变量，　

那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如