Thinking in Java ---ch07笔记

Ch07: Polymorphism(多形性)
    
    

对于面向对象的程序设计语言，多型性是第三种最基本的特征（前两种是数据抽象和继承）。

多形性的问题（也叫作动态绑定、推迟绑定或者运行期绑定）。

“多形性”（Polymorphism）从另一个角度将接口从具体的实施细节中分离出来，
亦即实现了“是什么”与“怎样做”两个模块的分离。(好好理解这句话)利用多形性的概念，
代码的组织以及可读性均能获得改善。此外，还能创建“易于扩展”的程序。无论在项目的创建过程中，
还是在需要加入新特性的时候，它们都可以方便地“成长”。

7.1 上溯造型

在第6章，大家已知道可将一个对象作为它自己的类型使用，或者作为它的基础类型的一个对象使用。
取得一个对象句柄，并将其作为基础类型句柄使用的行为就叫作“上溯造型”——因为继承树的画法是基础类位于
最上方。

例子：

//: Music.java 

// Inheritance & upcasting

package c07;

class Note {

  private int value;

  private Note(int val) { value = val; }

  public static final Note

    middleC = new Note(0), 

    cSharp = new Note(1),

    cFlat = new Note(2);

} // Etc.

class Instrument {

  public void play(Note n) {

    System.out.println("Instrument.play()");

  }

}

// Wind objects are instruments

// because they have the same interface:

class Wind extends Instrument {

  // Redefine interface method:

  public void play(Note n) {

    System.out.println("Wind.play()");

  }

}

public class Music {

  public static void tune(Instrument i) {

    // ...

    i.play(Note.middleC);

  }

  public static void main(String[] args) {

    Wind flute = new Wind();

    tune(flute); // Upcasting

  }

} ///:~
   
   

其中，方法Music.tune()接收一个Instrument句柄，同时也接收从Instrument衍生出来的所有东西。
当一个Wind句柄传递给tune()的时候，就会出现这种情况。此时没有造型的必要。这样做是可以接受的；
Instrument里的接口必须存在于Wind中，因为Wind是从Instrument里继承得到的。
从Wind向Instrument的上溯造型可能“缩小”那个接口，但不可能把它变得比Instrument的完整接口还要小。

7.1.1 为什么要上溯造型

上面例子中，如果让tune()简单地取得一个Wind句柄，将其作为自己的自变量使用，似乎会更加简单、
直观得多。但要注意：假如那样做，就需为系统内Instrument的每种类型写一个全新的tune()。
假设按照前面的推论，加入Stringed（弦乐）和Brass（铜管）这两种Instrument（乐器）。

//: Music2.java

//Overloading instead of upcasting

 

class Note2 {

      private int value;

 

      private Note2(int val) {

            value = val;

      }

 

      public static final Note2 middleC = new Note2(0), cSharp = new Note2(1),

                  cFlat = new Note2(2);

} // Etc.

 

class Instrument2 {

      public void play(Note2 n) {

            System.out.println("Instrument2.play()");

      }

}

 

class Wind2 extends Instrument2 {

      public void play(Note2 n) {

            System.out.println("Wind2.play()");

      }

}

 

class Stringed2 extends Instrument2 {

      public void play(Note2 n) {

            System.out.println("Stringed2.play()");

      }

}

 

class Brass2 extends Instrument2 {

      public void play(Note2 n) {

            System.out.println("Brass2.play()");

      }

}

 

public class Music2 {

 

     // 该tune代替了下面各个类型不同的tune

      public static void tune (Instrument2 i2){

            i2.play(Note2.middleC);

           

      }

      /*

      public static void tune(Wind2 i) {

            i.play(Note2.middleC);

      }

 

      public static void tune(Stringed2 i) {

            i.play(Note2.middleC);

      }

 

      public static void tune(Brass2 i) {

            i.play(Note2.middleC);

      }

*/

      public static void main(String[] args) {

            Wind2 flute = new Wind2();

            Stringed2 violin = new Stringed2();

            Brass2 frenchHorn = new Brass2();

            tune(flute); // No upcasting

            tune(violin);

            tune(frenchHorn);

      }

} // /:~

 

7.2 深入理解
对于Music.java的困难性，可通过运行程序加以体会。输出是Wind.play()。这当然是我们希望的输出，但它看起来似乎并不愿按我们的希望行事。请观察一下tune()方法：

public static void tune(Instrument i) {
// ...
i.play(Note.middleC);
}

它接收Instrument句柄。所以在这种情况下，编译器怎样才能知道Instrument句柄指向的是一个Wind，而不是一个Brass或Stringed呢？编译器无从得知。为了深入了理解这个问题，我们有必要探讨一下“绑定”这个主题。

7.2.1 方法调用的绑定

将一个方法调用同一个方法主体连接到一起就称为“绑定”（Binding）。

若在程序运行以前执行绑定（由编译器和链接程序，如果有的话），就叫作“早期绑定”。大家以前或许从未
听说过这个术语，因为它在任何程序化语言里都是不可能的。C编译器只有一种方法调用，那就是“早期绑定”。

上述程序最令人迷惑不解的地方全与早期绑定有关，因为在只有一个Instrument句柄的前提下，
编译器不知道具体该调用哪个方法。

解决的方法就是“后期绑定”，它意味着绑定在运行期间进行，以对象的类型为基础。
后期绑定也叫作“动态绑定”或“运行期绑定”。若一种语言实现了后期绑定，同时必须提供一些机制，
可在运行期间判断对象的类型，并分别调用适当的方法。也就是说，编译器此时依然不知道对象的类型，
但方法调用机制能自己去调查，找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。
但我们至少可以这样认为：它们都要在对象中安插某些特殊类型的信息。



 
 
 
 

Java中绑定的所有方法都采用后期绑定技术，除非一个方法已被声明成final。
这意味着我们通常不必决定是否应进行后期绑定——它是自动发生的。




   
   
 
 
 
 

为什么要把一个方法声明成final呢？正如上一章指出的那样，它能防止其他人覆盖那个方法。
但也许更重要的一点是，它可有效地“关闭”动态绑定，或者告诉编译器不需要进行动态绑定。
这样一来，编译器就可为final方法调用生成效率更高的代码。
   
   

7.2.2 产生正确的行为

在面向对象的程序设计中，有一个经典的“形状”例子。由于它很容易用可视化的形式表现出来，
所以经常都用它说明问题。

形状例子有一个基础类，名为Shape；另外还有大量衍生类型：Circle（圆形），Square（方形），
Triangle（三角形）等等。大家之所以喜欢这个例子，因为很容易理解“圆属于形状的一种类型”等概念。
下面这幅继承图向我们展示了它们的关系：

7.2.3 扩展性

让我们仍然返回乐器（Instrument）示例。由于存在多形性，所以可根据自己的需要向系统里加入任意多的
新类型，同时毋需更改true()方法。在一个设计良好的OOP程序中，我们的大多数或者所有方法都会遵从tune()
的模型，而且只与基础类接口通信。我们说这样的程序具有“扩展性”，因为可以从通用的基础类继承新的数据
类型，从而新添一些功能。如果是为了适应新类的要求，那么对基础类接口进行操纵的方法根本不需要改变，

对于乐器例子，假设我们在基础类里加入更多的方法，以及一系列新类，那么会出现什么情况呢？
下面是示意图：

7.5 接口

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

它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。
接口也包含了基本数据类型的数据成员，但它们都默认为static和final。接口只提供一种形式，
并不提供实施的细节。

接口这样描述自己：“对于实现我的所有类，看起来都应该象我现在这个样子”。因此，采用了一个特定接口
的所有代码都知道对于那个接口可能会调用什么方法。这便是接口的全部含义。所以我们常把接口用于建立
类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol”（协议）的关键字，
它做的便是与接口相同的事情。

为创建一个接口，请使用interface关键字，而不要用class。与类相似，我们可在interface关键字
的前面增加一个public关键字（但只有接口定义于同名的一个文件内）；或者将其省略，营造一种“友好的”
状态。
   
   

可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义，它们也会默认为public。
所以在实现一个接口的时候，来自接口的方法必须定义成public。否则的话，它们会默认为“友好的”，
而且会限制我们在继承过程中对一个方法的访问——Java编译器不允许我们那样做。例子：

//: Music5.java

// Interfaces

import java.util.*;

interface Instrument5 {

  // Compile-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 {

  // 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的“多重继承”
    
    

java中，继承只能继承于一个基础类，而可以同时实现多个接口，即多继承。

例子：

//: 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); // upcasting Treat it as a CanFight
  
  

u(i); // upcasting Treat it as a CanSwim

    v(i); // upcasting Treat it as a CanFly

    w(i); // upcasting Treat it as an ActionCharacter

  }

} ///:~

接口的规则是：我们可以从它继承（稍后就会看到），但这样得到的将是另一个接口
。如果想创建新类型的一个对象，它就必须是已提供所有定义的一个类。
尽管Hero没有为fight()明确地提供一个定义，但定义是随同ActionCharacter来的，
所以这个定义会自动提供，我们可以创建Hero的对象。

在类Adventure中，我们可看到共有四个方法，它们将不同的接口和具体类作为自己的自变量使用。
创建一个Hero对象后，它可以传递给这些方法中的任何一个。这意味着它们会依次上溯造型到每一个接口。
由于接口是用Java设计的，所以这样做不会有任何问题，而且程序员不必对此加以任何特别的关注。

7.5.2 通过继承扩展接口
利用继承技术，可方便地为一个接口添加新的方法声明，也可以将几个接口合并成一个新接口。

在这两种情况下，最终得到的都是一个新接口，如下例所示：

//: HorrorShow.java

// Extending an interface with inheritance

interface Monster {

  void menace();

}

interface DangerousMonster extends Monster {

  void destroy();

}

interface Lethal {

  void kill();

}

class DragonZilla implements DangerousMonster {

  public void menace() {}

  public void destroy() {}

}

interface Vampire 

    extends DangerousMonster, Lethal {

  void drinkBlood();

}

class HorrorShow {

  static void u(Monster b) { b.menace(); }

  static void v(DangerousMonster d) {

    d.menace();

    d.destroy();

  }

  public static void main(String[] args) {

    DragonZilla if2 = new DragonZilla();

    u(if2);

    v(if2);

  }

} ///
   
   

7.5.3 常数分组
由于置入一个接口的所有字段都自动具有static和final属性，所以接口是对常数值进行分组的一个好工具，它具有与C或C++的enum非常相似的效果。如下例所示：

//: Months.java

// Using interfaces to create groups of constants

package c07;

 

public interface Months {

  int

    JANUARY = 1, FEBRUARY = 2, MARCH = 3,

    APRIL = 4, MAY = 5, JUNE = 6, JULY = 7,

    AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10,

    NOVEMBER = 11, DECEMBER = 12;

} ///:~

注意根据Java命名规则，拥有固定标识符的static final基本数据类型（亦即编译期常数）
都全部采用大写字母（用下划线分隔单个标识符里的多个单词）。

接口中的字段会自动具备public属性，所以没必要专门指定。
   
   

7.5.4 初始化接口中的字段
接口中定义的字段会自动具有static和final属性。它们不能是“空白final”，

但可初始化成非常数表达式。例如：

//: RandVals.java

// Initializing interface fields with

// non-constant initializers

import java.util.*;

 

public interface RandVals {

  int rint = (int)(Math.random() * 10);

  long rlong = (long)(Math.random() * 10);

  float rfloat = (float)(Math.random() * 10);

  double rdouble = Math.random() * 10;

} ///:~

由于字段是static的，所以它们会在首次装载类之后、以及首次访问任何字段之前获得初始。下面是一个简单的测试：

//: TestRandVals.java

 

public class TestRandVals {

  public static void main(String[] args) {

    System.out.println(RandVals.rint);

    System.out.println(RandVals.rlong);

    System.out.println(RandVals.rfloat);

    System.out.println(RandVals.rdouble);

  }

} ///:~

当然，字段并不是接口的一部分，而是保存于那个接口的static存储区域中。


7.6 内部类

在Java 1.1中，可将一个类定义置入另一个类定义中。这就叫作“内部类”。内部类对我们非常有用，因为利用它可对那些逻辑上相互联系的类进行分组，并可控制一个类在另一个类里的“可见性”。然而，我们必须认识到内部类与以前讲述的“合成”方法存在着根本的区别。

通常，对内部类的需要并不是特别明显的，至少不会立即感觉到自己需要使用内部类。
  
  
   
    
  
  7.6.1 内部类和上溯造型
    
    普通（非内部）类不可设为private或protected——只允许public或者“友好的”。

注意Contents不必成为一个抽象类。在这儿也可以使用一个普通类，但这种设计最典型的起点依然是一个“接口”。
  
  
   
    
  
  7.6.2 方法和作用域中的内部类

对那些涉及内部类的代码，通常表达的都是“单纯”的内部类，非常简单，且极易理解。然而，内部类的设计非常全面，不可避免地会遇到它们的其他大量用法——假若我们在一个方法甚至一个任意的作用域内创建内部类。有两方面的原因促使我们这样做：

(1) 正如前面展示的那样，我们准备实现某种形式的接口，使自己能创建和返回一个句柄。

(2) 要解决一个复杂的问题，并希望创建一个类，用来辅助自己的程序方案。同时不愿意把它公开。



在下面这个例子里，将修改前面的代码，以便使用：

(1) 在一个方法内定义的类

(2) 在方法的一个作用域内定义的类

(3) 一个匿名类，用于实现一个接口

(4) 一个匿名类，用于扩展拥有非默认构建器的一个类

(5) 一个匿名类，用于执行字段初始化

(6) 一个匿名类，通过实例初始化进行构建（匿名内部类不可拥有构建器）
   
   1． 匿名类的一个例子：
   
   //: Parcel6.java// A method that returns an anonymous inner classpackage c07.innerscopes;
  
  
   
    
  
  public class Parcel6 {  public Contents cont() {    return new Contents() {      private int i = 11;      public int value() { return i; }    }; // Semicolon required in this case  }  public static void main(String[] args) {    Parcel6 p = new Parcel6();    Contents c = p.cont();  }} ///:~

cont()方法同时合并了返回值的创建代码，以及用于表示那个返回值的类。除此以外，这个类是匿名的——它没有名字。而且看起来似乎更让人摸不着头脑的是，我们准备创建一个Contents对象：

return new Contents()

但在这之后，在遇到分号之前，我们又说：“等一等，让我先在一个类定义里再耍一下花招”：



return new Contents() {

private int i = 11;

public int value() { return i; }

};



这种奇怪的语法要表达的意思是：“创建从Contents衍生出来的匿名类的一个对象”。由new表达式返回的句柄会自动上溯造型成一个Contents句柄。匿名内部类的语法其实要表达的是：



class MyContents extends Contents {

private int i = 11;

public int value() { return i; }

}

return new MyContents();
   
   
   
   
    
     
   
   在匿名内部类中，Contents是用一个默认构建器创建的。
    
    
    
    
     
      
    
    2．若试图定义一个匿名内部类，并想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。
   
   
  
  
   
    
  
  //: Parcel8.java// An anonymous inner class that performs // initialization. A briefer version// of Parcel5.java.package c07.innerscopes;
  
  
   
    
  
  public class Parcel8 {  // Argument must be final to use inside   // anonymous inner class:  public Destination dest(final String dest) {    return new Destination() {      private String label = dest;      public String readLabel() { return label; }    };  }  public static void main(String[] args) {    Parcel8 p = new Parcel8();    Destination d = p.dest("
  
  
   
   
    
    Tanzania
   
   
  
  ");  }} ///:~

若试图定义一个匿名内部类，并想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。这正是我们将dest()的自变量设为final的原因。如果忘记这样做，就会得到一条编译期出错提示。
  
  
   
    
  
  3．匿名内部类的构造器
   
   

但假如需要采取一些类似于构建器的行动，又应怎样操作呢？通过Java 1.1的实例初始化，我们可以有效地为一个匿名内部类创建一个构建器：

//: Parcel9.java

// Using "instance initialization" to perform

// construction on an anonymous inner class

package c07.innerscopes;

 

public class Parcel9 {

  public Destination

  dest(final String dest, final float price) {

    return new Destination() {

      private int cost;

      // Instance initialization for each object:

      {

        cost = Math.round(price);

        if(cost > 100)

          System.out.println("Over budget!");

      }

      private String label = dest;

      public String readLabel() { return label; }

    };

  }

  public static void main(String[] args) {

    Parcel9 p = new Parcel9();

    Destination d = p.dest(" Tanzania ", 101.395F);

  }

} ///:~

在实例初始化模块中，我们可看到代码不能作为类初始化模块（即if语句）的一部分执行。所以实际上，一个实例初始化模块就是一个匿名内部类的构建器。当然，它的功能是有限的；我们不能对实例初始化模块进行过载处理，所以只能拥有这些构建器的其中一个。  

7.6.3 链接到外部类
创建自己的内部类时，那个类的对象同时拥有指向封装对象（这些对象封装或生成了内部类）的一个链接。所以它们能访问那个封装对象的成员——毋需取得任何资格。

//: Sequence.java

// Holds a sequence of Objects

 

interface Selector {

  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++;

    }

  }

  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();

    }

  }

} ///:~

其中，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.6 从内部类继承
由于内部类构建器必须同封装类对象的一个句柄联系到一起，所以从一个内部类继承的时候，情况会稍微变得有些复杂。这儿的问题是封装类的“秘密”句柄必须获得初始化，而且在衍生类中不再有一个默认的对象可以连接。解决这个问题的办法是采用一种特殊的语法，明确建立这种关联：

//: InheritInner.java

// Inheriting an inner class

 

class WithInner {

  class Inner {}

}

 

public class InheritInner

    extends WithInner.Inner {

  //! InheritInner() {} // Won't compile

  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 内部类可以覆盖吗？
这个例子简单地揭示出当我们从外部类继承的时候，没有任何额外的内部类继续下去。然而，仍然有可能“明确”地从内部类继承：

//: 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()");

    }

    public void f() {

      System.out.println("BigEgg2.Yolk.f()");

    }

  }

  public BigEgg2() { insertYolk(new Yolk()); }

  public static void main(String[] args) {

    Egg2 e2 = new BigEgg2();

    e2.g();

  }

} ///:~

现在，BigEgg2.Yolk明确地扩展了Egg2.Yolk，而且覆盖了它的方法。方法insertYolk()允许BigEgg2将它自己的某个Yolk对象上溯造型至Egg2的y句柄。所以当g()调用y.f()的时候，就会使用f()被覆盖版本。输出结果如下：

Egg2.Yolk()

New Egg2()

Egg2.Yolk()

BigEgg2.Yolk()

BigEgg2.Yolk.f()

对Egg2.Yolk()的第二个调用是BigEgg2.Yolk构建器的基础类构建器调用。调用

g()的时候，可发现使用的是f()的被覆盖版本。

7.6.9 为什么要用内部类：控制框架

为什么Sun要如此麻烦地在Java 1.1里添加这样的一种基本语言特性呢？答案就在于我们在这里要学习的“控制框架”。

一个“应用程序框架”是指一个或一系列类，它们专门设计用来解决特定类型的问题。为应用应用程序框架，我们可从一个或多个类继承，并覆盖其中的部分方法。我们在覆盖方法中编写的代码用于定制由那些应用程序框架提供的常规方案，以便解决自己的实际问题。“控制框架”属于应用程序框架的一种特殊类型，受到对事件响应的需要的支配；主要用来响应事件的一个系统叫作“由事件驱动的系统”。在应用程序设计语言中，最重要的问题之一便是“图形用户界面”（GUI），它几乎完全是由事件驱动的。  

7.7.1 构建器的调用顺序
 
用于基础类的构建器肯定在一个衍生类的构建器中调用，而且逐渐向上链接，使每个基础类使用的构建器都能得到调用。

 

之所以要这样做，是由于构建器负有一项特殊任务：检查对象是否得到了正确的构建。一个衍生类只能访问它自己的成员，不能访问基础类的成员（这些成员通常都具有private属性）。

 

只有基础类的构建器在初始化自己的元素时才知道正确的方法以及拥有适当的权限。

 

所以，必须令所有构建器都得到调用，否则整个对象的构建就可能不正确。那正是编译器为什么要强迫对衍生类的每个部分进行构建器调用的原因。在衍生类的构建器主体中，若我们没有明确指定对一个基础类构建器的调用，它就会“默默”地调用默认构建器。如果不存在默认构建器，编译器就会报告一个错误（若某个类没有构建器，编译器会自动组织一个默认构建器）。
下面让我们看看一个例子，它展示了按构建顺序进行合成、继承以及多形性的效果：

package ThinkingJava.ch07;

 

//: Sandwich.java

//Order of constructor calls

 

class Meal {

      static int i=geti("meal_static");

      int j =geti("meal_normal");

     

      static int geti(String str){

            System.out.println(str);

            return 10;

      }

      Meal() {

            System.out.println("Meal()");

      }

}

 

class Bread {

      Bread() {

            System.out.println("Bread()");

      }

}

 

class Cheese {

      Cheese() {

            System.out.println("Cheese()");

      }

}

 

class Lettuce {

      Lettuce() {

            System.out.println("Lettuce()");

      }

}

 

class Lunch extends Meal {

      static int i=geti("Lunch_static");

      int j =geti("Lunch_normal");

     

     

      Lunch() {

            System.out.println("Lunch()");

      }

}

 

class PortableLunch extends Lunch {

      PortableLunch() {

            System.out.println("PortableLunch()");

      }

}

 

class Sandwich extends PortableLunch {

      static int i=geti("Sandwich_static");

      int j =geti("Sandwich_normal");

      Bread b = new Bread();

      Cheese c = new Cheese();

      Lettuce l = new Lettuce();

 

      Sandwich () {

            System.out.println(" Sandwich ()");

      }

      public static void main(String[] args) {

            new Sandwich ();

      }

} // /:~
这个例子在其他类的外部创建了一个复杂的类，而且每个类都有一个构建器对自己进行了宣布。其中最重要的类是Sandwich，它反映出了三个级别的继承（若将从Object的默认继承算在内，就是四级）以及三个成员对象。在main()里创建了一个Sandwich对象后，输出结果如下：

meal_static

Lunch_static

Sandwich_static

meal_normal

Meal()

Lunch_normal

Lunch()

PortableLunch()

Sandwich_normal

Bread()

Cheese()

Lettuce()

Sandwich()

这意味着对于一个复杂的对象，构建器的调用遵照下面的顺序： (0) 各级基础类和继承类的static变量按顺序初始化

(1) 基础类的normal 变量初始化调用基础类构建器。这个步骤会不断重复下去，首先得到构建的是分级结构的根部，然后是下一个衍生类，等等。直到抵达最深一层的衍生类。

//(2) 按声明顺序调用成员初始化模块。

(3) 调用衍生构建器的主体。

注：本章的最后几节看得不是很详细，看到后面章节时可以再回头看