為什麼Java中繼承多數是有害的

大多數好的設計者象躲避瘟疫一樣來避免使用實現繼續(extends 關系)。實際上80%的代碼應該完全用interfaces寫，而不是通過extends。“Java設計模式”一書具體闡述了怎樣用接口繼續代替實現繼續。這篇文章描述設計者為什麼會這麼作。
　　
　　 <!-- frame contents --> <!-- /frame contents --> 　　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原則，如實現隱藏，我結果重寫那個代碼（一般因為代碼是不可調試的）。我沒有時間重寫代碼，所以我遵循那些規則。我關心的完全實用？我對干淨的原因沒有愛好。