### [繼承和清理](https://lingcoder.gitee.io/onjava8/#/book/09-Polymorphism?id=%e7%bb%a7%e6%89%bf%e5%92%8c%e6%b8%85%e7%90%86) 在使用組合和繼承創建新類時，大部分時候你無需關心清理。子對象通常會留給垃圾收集器處理。如果你存在清理問題，那么必須用心地為新類創建一個`dispose()`方法（這里用的是我選擇的名稱，你可以使用更好的名稱）。由于繼承，如果有其他特殊的清理工作的話，就必須在派生類中重寫`dispose()`方法。當重寫`dispose()`方法時，記得調用基類的`dispose()`方法，否則基類的清理工作不會發生： ~~~ // polymorphism/Frog.java // Cleanup and inheritance // {java polymorphism.Frog} package polymorphism; class Characteristic { private String s; Characteristic(String s) { this.s = s; System.out.println("Creating Characteristic " + s); } protected void dispose() { System.out.println("disposing 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("disposing 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()"); } @Override 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()"); } @Override protected void dispose() { System.out.println("Amphibian dispose"); t.dispose(); p.dispose(); super.dispose(); } } public class Frog extends Amphibian { private Characteristic p = new Characteristic("Croaks"); private Description t = new Description("Eats Bugs"); public Frog() { System.out.println("Frog()"); } @Override 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(); } } ~~~ 輸出： ~~~ Creating Characteristic is alive Creating Description Basic Living Creature LivingCreature() Creating Characteristiv 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 disposing Description Eats Bugs disposing Characteristic Croaks Amphibian dispose disposing Description Both wanter and land disposing Characteristic can live in water Animal dispose disposing Description Animal not Vegetable disposing Characteristic has heart LivingCreature dispose disposing Description Basic Living Creature disposing Characteristic is alive ~~~ 層級結構中的每個類都有**Characteristic**和**Description**兩個類型的成員對象，它們必須得被銷毀。銷毀的順序應該與初始化的順序相反，以防一個對象依賴另一個對象。對于屬性來說，就意味著與聲明的順序相反（因為屬性是按照聲明順序初始化的）。對于基類（遵循 C++ 析構函數的形式），首先進行派生類的清理工作，然后才是基類的清理。這是因為派生類的清理可能調用基類的一些方法，所以基類組件這時得存活，不能過早地被銷毀。輸出顯示了，**Frog**對象的所有部分都是按照創建的逆序銷毀的。 盡管通常不必進行清理工作，但萬一需要時，就得謹慎小心地執行。 **Frog**對象擁有自己的成員對象，它創建了這些成員對象，并且知道它們能存活多久，所以它知道何時調用`dispose()`方法。然而，一旦某個成員對象被其它一個或多個對象共享時，問題就變得復雜了，不能只是簡單地調用`dispose()`。這里，也許就必須使用*引用計數*來跟蹤仍然訪問著共享對象的對象數量，如下： ~~~ // polymorphism/ReferenceCounting.java // Cleaning up shared member objects class Shared { private int refcount = 0; private static long counter = 0; private final long id = counter++; Shared() { System.out.println("Creating " + this); } public void addRef() { refcount++; } protected void dispose() { if (--refcount == 0) { System.out.println("Disposing " + this); } } @Override public String toString() { return "Shared " + id; } } class Composing { private Shared shared; private static long counter = 0; private final long id = counter++; Composing(Shared shared) { System.out.println("Creating " + this); this.shared = shared; this.shared.addRef(); } protected void dispose() { System.out.println("disposing " + this); shared.dispose(); } @Override public String toString() { return "Composing " + id; } } public class ReferenceCounting { public static void main(String[] args) { Shared shared = new Shared(); Composing[] composing = { new Composing(shared), new Composing(shared), new Composing(shared), new Composing(shared), new Composing(shared), }; for (Composing c: composing) { c.dispose(); } } } ~~~ 輸出： ~~~ Creating Shared 0 Creating Composing 0 Creating Composing 1 Creating Composing 2 Creating Composing 3 Creating Composing 4 disposing Composing 0 disposing Composing 1 disposing Composing 2 disposing Composing 3 disposing Composing 4 Disposing Shared 0 ~~~ **static long counter**跟蹤所創建的**Shared**實例數量，還提供了**id**的值。**counter**的類型是**long**而不是**int**，以防溢出（這只是個良好實踐，對于本書的所有示例，**counter**不會溢出）。**id**是**final**的，因為它的值在初始化時確定后不應該變化。 在將一個**shared**對象附著在類上時，必須記住調用`addRef()`，而`dispose()`方法會跟蹤引用數，以確定在何時真正地執行清理工作。使用這種技巧需要加倍細心，但是如果正在共享需要被清理的對象，就沒有太多選擇了。