继承与清除

通过组合和继承方法来创建新类时，我们永远不必担心对象的清除问题，子对象
（subobject）通常都会留给垃圾回收器进行处理。如果要是遇到清除的问题，那么我们必
须不断地为我们的新类创建 dispose( )方法（在这里我选用此名称；你可以提出更好的）。
并且由于继承的缘故，如果我们有其他作为垃圾回收一部分的特殊清除动作，就必须重载导
出类中的 dispose( )方法。重载继承类的 dispose( )方法时，务必记住调用基类版本
dispose( )方法。否则，基类的清除动作就不会发生。下例将予以证明：


//: c07:Frog.java
// Cleanup and inheritance.
import com.bruceeckel.simpletest.*; 


class Characteristic {
private String s; 
  Characteristic(String s) { 
this.s = s; 
    System.out.println("Creating Characteristic " + s);
  }
protected void dispose() { 
    System.out.println("finalizing Characteristic " + s); 
  }
}


class Description { 
private String s; 
  Description(String s) { 
this.s = s; 
    System.out.println("Creating Description " + s);
  }
protected void dispose() { 
    System.out.println("finalizing Description " + s); 
  }
}


class LivingCreature {
private Characteristic p = new Characteristic("is alive"); 
private Description t = 
new Description("Basic Living Creature"); 
  LivingCreature() { 
    System.out.println("LivingCreature()"); 
  }
 






protected void dispose() { 
    System.out.println("LivingCreature dispose"); 
    t.dispose();
    p.dispose();
  }
}


class Animal extends LivingCreature { 
private Characteristic p= new Characteristic("has heart"); 
private Description t = 
new Description("Animal not Vegetable");
  Animal() {
    System.out.println("Animal()");
  }
protected void dispose() { 
    System.out.println("Animal dispose");
    t.dispose();
    p.dispose();
super.dispose(); 
  }
}


class Amphibian extends Animal {
private Characteristic p = 
new Characteristic("can live in water");
private Description t = 
new Description("Both water and land"); 
  Amphibian() {
    System.out.println("Amphibian()"); 
  }
protected void dispose() { 
    System.out.println("Amphibian dispose");
    t.dispose();
    p.dispose();
super.dispose(); 
  }
}


public class Frogextends Amphibian { 
private static Test monitor = new Test(); 
private Characteristic p = new Characteristic("Croaks"); 
private Description t = new Description("Eats Bugs");
public Frog() { 
    System.out.println("Frog()");
 
  }
protected void dispose() { 
    System.out.println("Frog dispose");
    t.dispose();
    p.dispose();
super.dispose(); 
  }
public static void main(String[] args) { 
    Frog frog = new Frog(); 
    System.out.println("Bye!"); 
    frog.dispose();
    monitor.expect(new String[] { 
"Creating Characteristic is alive",
"Creating Description Basic Living Creature",
"LivingCreature()",
"Creating Characteristic has heart",
"Creating Description Animal not Vegetable",
"Animal()",
"Creating Characteristic can live in water",
"Creating Description Both water and land",
"Amphibian()",
"Creating Characteristic Croaks",
"Creating Description Eats Bugs",
"Frog()",
"Bye!",
"Frog dispose",
"finalizing Description Eats Bugs",
"finalizing Characteristic Croaks",
"Amphibian dispose",
"finalizing Description Both water and land",
"finalizing Characteristic can live in water",
"Animal dispose",
"finalizing Description Animal not Vegetable",
"finalizing Characteristic has heart",
"LivingCreature dispose",
"finalizing Description Basic Living Creature",
"finalizing Characteristic is alive"
    });
  }
} ///:~


层次结构中的每个类都包含 Characteristic 和Description 这两种类型的成员对象，
并且也必须对它们进行处理。所以万一某个子对象要依赖于其他对象，处理的顺序应该和初
始化顺序相反。对于属性，则意味着与声明的顺序相反（因为属性的初始化是按照声明的顺
序进行）。对于基类（遵循 C++中析构函数的形式），我们应该首先对其导出类进行清除，
然后才是基类。这是因为导出类的清除可能会调用基类中的某些方法，所以需要使基类中的
构件仍起作用而不应过早地销毁她。从输出结果我们可以看到，Frog 对象的所有部分都是
按照创建的逆序进行销毁。


在这个例子中可以看到，尽管我们通常不必执行清除处理，但是一旦你选择要执行，就必须

谨慎和小心。