為什麼Java中繼承是有害的

大多數好的設計者象躲避瘟疫一樣來避免使用實現繼承(extends 關係)。實際上80%的代碼應該完全用interfaces寫，而不是通過extends。“JAVA設計模式”一書詳細闡述了怎樣用介面繼承代替實現繼承。這篇文章描述設計者為什麼會這麼作。 

　　Extends是有害的；也許對於Charles Manson這個層級的不是，但是足夠糟糕的它應該在任何可能的時候被避開。“JAVA設計模式”一書花了很大的部分討論用interface繼承代替實現繼承。 

　　好的設計者在他的代碼中，大部分用interface，而不是具體的基類。本文討論為什麼設計者會這樣選擇，並且也介紹一些基於interface的編程基礎。 

介面（Interface）和類（Class）? 

　　一次，我參加一個Java使用者組的會議。在會議中，Jams Gosling（Java之父）做發起人講話。在那令人難忘的Q&A部分，有人問他：“如果你重新構造Java，你想改變什嗎？”。“我想拋棄classes”他回答。在笑聲平息後，它解釋說，真正的問題不是由於class本身，而是實現繼承(extends 關係)。介面繼承（implements關係）是更好的。你應該儘可能的避免實現繼承。 

失去了靈活性 

　　為什麼你應該避免實現繼承呢？第一個問題是明確的使用具體類名將你固定到特定的實現，給底層的改變增加了不必要的困難。 

　　在當前的敏捷編程方法中，核心是並行的設計和開發的概念。在你詳細設計程式前，你開始編程。這個技術不同於傳統方法的形式----傳統的方式是設計應該在編碼開始前完成----但是許多成功的項目已經證明你能夠更快速的開發高品質代碼，相對於傳統的按部就班的方法。但是在並行開發的核心是主張靈活性。你不得不以某一種方式寫你的代碼以至於最新發現的需求能夠儘可能沒有痛苦的合并到已有的代碼中。 

　　勝於實現你也許需要的特徵，你只需實現你明確需要的特徵，而且適度的對變化的包容。如果你沒有這種靈活，並行的開發，那簡直不可能。 

　　對於Inteface的編程是靈活結構的核心。為了說明為什麼，讓我們看一下當使用它們的時候，會發生什麼。考慮下面的代碼： 

f()
{   LinkedList list = new LinkedList();
    //...
    g( list );
}

g( LinkedList list )
{
    list.add( ... );
    g2( list )
}
 

　　現在，假設一個對於快速查詢的需求被提出，以至於這個LinkedList不能夠解決。你需要用HashSet來代替它。在已有代碼中，變化不能夠局部化，因為你不僅僅需要修改f()也需要修改g()（它帶有LinkedList參數），並且還有g()把列表傳遞給的任何代碼。象下面這樣重寫代碼: 

f()
{   Collection list = new LinkedList();
    //...
    g( list );
}

g( Collection list )
{
    list.add( ... );
    g2( list )
}
 

　　這樣修改Linked list成hash，可能只是簡單的用new HashSet()代替new LinkedList()。就這樣。沒有其他的需要修改的地方。 

　　作為另一個例子，比較下面兩段代碼： 

f()
{   Collection c = new HashSet();
    //...
    g( c );
}

g( Collection c )
{
    for( Iterator i = c.iterator(); i.hasNext() )
        do_something_with( i.next() );
}
 

和 

f2()
{   Collection c = new HashSet();
    //...
    g2( c.iterator() );
}

g2( Iterator i )
{   while( i.hasNext() )
        do_something_with( i.next() );
}
 

　　g2()方法現在能夠遍曆Collection的派生，就像你能夠從Map中得到的索引值對。事實上，你能夠寫iterator，它產生資料，代替遍曆一個Collection。你能夠寫iterator，它從測試的架構或者檔案中得到資訊。這會有巨大的靈活性。 

耦合 

　　對於實現繼承，一個更加關鍵的問題是耦合---令人煩躁的依賴，就是那種程式的一部分對於另一部分的依賴。全域變數提供經典的例子，證明為什麼強耦合會引起麻煩。例如，如果你改變全域變數的類型，那麼所有用到這個變數的函數也許都被影響，所以所有這些代碼都要被檢查，變更和重新測試。而且，所有用到這個變數的函數通過這個變數相互耦合。也就是，如果一個變數值在難以使用的時候被改變，一個函數也許就不正確的影響了另一個函數的行為。這個問題顯著的隱藏於多線程的程式。 

　　作為一個設計者，你應該努力最小化耦合關係。你不能一併消除耦合，因為從一個類的對象到另一個類的對象的方法調用是一個松耦合的形式。你不可能有一個程式，它沒有任何的耦合。然而，你能夠通過遵守OO規則，最小化一定的耦合（最重要的是，一個對象的實現應該完全隱藏於使用他的對象）。例如，一個對象的執行個體變數（不是常量的成員域），應該總是private。我意思是某段時期的，無例外的，不斷的。（你能夠偶爾有效地使用protected方法，但是protected執行個體變數是可憎的事）同樣的原因你應該不用get/set函數---他們對於是一個域公用只是使人感到過於複雜的方式（儘管返回修飾的對象而不是基本類型值的訪問函數是在某些情況下是由原因的，那種情況下，返回的對象類是一個在設計時的關鍵抽象）。 

　　這裡，我不是書生氣。在我自己的工作中，我發現一個直接的相互關係在我OO方法的嚴格之間，快速代碼開發和容易的代碼實現。無論什麼時候我違反中心的OO原則，如實現隱藏，我結果重寫那個代碼（一般因為代碼是不可調試的）。我沒有時間重寫代碼，所以我遵循那些規則。我關心的完全實用?我對乾淨的原因沒有興趣。 

脆弱的基類問題 

　　現在，讓我們應用耦合的概念到繼承。在一個用extends的繼承實現系統中，衍生類別是非常緊密的和基類別結合程度，當且這種緊密的串連是不期望的。設計者已經應用了綽號“脆弱的基類問題”去描述這個行為。基礎類被認為是脆弱的是，因為你在看起來安全的情況下修改基類，但是當從衍生類別繼承時，新的行為也許引起衍生類別出現功能紊亂。你不能通過簡單的在隔離下檢查基類的方法來分辨基類的變化是安全的；而是你也必須看（和測試）所有衍生類別。而且，你必須檢查所有的代碼，它們也用在基類和衍生類別對象中，因為這個代碼也許被新的行為所打破。一個對於基礎類的簡單變化可能導致整個程式不可操作。 

　　讓我們一起檢查脆弱的基類和基類別結合程度的問題。下面的類extends了Java的ArrayList類去使它像一個stack來運轉： 

class Stack extends ArrayList
{   private int stack_pointer = 0;

    public void push( Object article )
    {   add( stack_pointer++, article );
    }

    public Object pop()
    {   return remove( --stack_pointer );
    }

    public void push_many( Object[] articles )
    {   for( int i = 0; i < articles.length; ++i )
            push( articles[i] );
    }
}
 

甚至一個象這樣簡單的類也有問題。思考當一個使用者平衡繼承和用ArrayList的clear()方法去彈出堆棧時： 

Stack a_stack = new Stack();
a_stack.push("1");
a_stack.push("2");
a_stack.clear();
 

　　這個代碼成功編譯，但是因為基類不知道關於stack指標堆棧的情況,這個stack對象當前在一個未定義的狀態。下一個對於push（）調用把新的項放入索引2的位置。（stack_pointer的當前值），所以stack有效地有三個元素-下邊兩個是垃圾。（Java的stack類正是有這個問題，不要用它）. 

　　對這個令人討厭的繼承的方法問題的解決辦法是為Stack覆蓋所有的ArrayList方法，那能夠修改數組的狀態，所以覆蓋正確的操作Stack指標或者拋出一個例外。(removeRange()方法對於拋出一個例外一個好的候選方法)。 

　　這個方法有兩個缺點。第一，如果你覆蓋了所有的東西，這個基類應該真正的是一個interface，而不是一個class。如果你不用任何繼承方法，在實現繼承中就沒有這一點。第二，更重要的是，你不能夠讓一個stack支援所有的ArrayList方法。例如，令人煩惱的removeRange()沒有什麼作用。唯一實現無用方法的合理的途徑是使它拋出一個例外，因為它應該永遠不被調用。這個方法有效把編譯錯誤成為運行錯誤。不好的方法是，如果方法只是不被定義，編譯器會輸出一個方法未找到的錯誤。如果方法存在，但是拋出一個例外，你只有在程式真正的運行時，你才能夠發現調用錯誤。 

　　對於這個基類問題的一個更好的解決辦法是封裝資料結構代替用繼承。這是新的和改進的Stack的版本： 

class Stack
{
    private int stack_pointer = 0;
    private ArrayList the_data = new ArrayList();
    
    public void push( Object article )
{
    the_data.add( stack_poniter++, article );
}

public Object pop()
{
    return the_data.remove( --stack_pointer );
}

public void push_many( Object[] articles )
{
    for（ int i = 0; i < o.length; ++i ）
        push( articles[i] );
}
}
 

　　到現在為止，一直都不錯，但是考慮脆弱的基類問題，我們說你想要在stack建立一個變數， 用它在一段周期內跟蹤最大的堆棧尺寸。一個可能的實現也許象下面這樣: 

class Monitorable_stack extends Stack
{
    private int high_water_mark = 0;
    private int current_size;

    public void push( Object article )
    {
        if( ++current_size > high_water_mark )
            high_water_mark = current_size;
        super.push( article );
    }

    publish Object pop()
    {
        --current_size;
        return super.pop();
    }

    public int maximum_size_so_far()
    {
        return high_water_mark;
    }
}
 

　　這個新類啟動並執行很好，至少是一段時間。不幸的是，這個代碼發掘了一個事實，push_many()通過調用push()來運行。首先，這個細節看起來不是一個壞的選擇。它簡化了代碼，並且你能夠得到push()的衍生類別版本，甚至當Monitorable_stack通過Stack的參考來訪問的時候，以至於high_water_mark能夠正確的更新。