2. 程式人生 > >組合優於繼承

組合優於繼承

阿新 • • 發佈：2018-11-15

《Effective Java 中文版第2版》書中第16條中說到：

繼承是實現程式碼複用的有力手段，但它並非永遠是完成這項工作的的最佳工具。

組合優於繼承。

繼承有什麼問題？

繼承打破了類的封裝性，子類依賴於父類中特定功能的實現細節。

繼承什麼時候是安全的

  • 在包的內部是用繼承，不存在跨包繼承。
  • 專門為了擴充套件而設計，並且具備很好的文件說明。

一個例子

實現這樣一個HashSet，可以跟蹤從它被建立之後曾經新增過幾個元素。

使用繼承實現

public class InstrumentedSet<E> extends HashSet<E
 
> {
  // The number of attempted element insertions
  private int addCount = 0;

  public InstrumentedSet() {
  }

  public InstrumentedSet(int initCap, float loadFactor) {
    super(initCap, loadFactor);
  }

  @Override
  public boolean add(E e) {
    addCount++;
    return super.add(e);
  }

  @Override
 

  public boolean addAll(Collection<? extends E> c) {
    addCount += c.size();
    return super.addAll(c);
  }

  public int getAddCount() {
    return addCount;
  }
}
複製程式碼

類中使用 addCount 欄位記錄新增元素的次數，並覆蓋父類的 add()和 addAll() 實現，對 addCount 欄位進行設值。

在下面的程式中，我們期望 getAddCount() 返回3，但實際上返回的是6。

InstrumentedSet<String> s = new
 
 InstrumentedSet<String>();
s.addAll(Arrays.asList("Snap", "Crackle", "Pop"));
複製程式碼

問題出在於：在 HashSet 中，addAll() 的實現是基於 add() 方法的。子類在擴充套件父類的功能時，如果不清楚實現細節，是非常危險的，況且父類的實現在未來可能是變化的，畢竟它並不是為擴充套件而設計的。

使用組合實現

不用擴充套件現有的類，而是在新的類中增加一個私有欄位，引用現有類的例項。這種設計被叫做組合。

先建立一個乾淨的 SetWrapper 組合類。

public class SetWrapper<E> implements Set<E> {
  private final Set<E> s;
  public SetWrapper(Set<E> s) { this.s = s; }
  public void clear()               { s.clear();            }
  public boolean contains(Object o) { return s.contains(o); }
  public boolean isEmpty() { return s.isEmpty();   }
  public int size() { return s.size();      }
  public Iterator<E> iterator() { return s.iterator();  }
  public boolean add(E e) { return s.add(e);      }
  public boolean remove(Object o){ return s.remove(o);   }
  public boolean containsAll(Collection<?> c) { return s.containsAll(c); }
  public boolean addAll(Collection<? extends E> c) { return s.addAll(c);      }
  public boolean removeAll(Collection<?> c) { return s.removeAll(c);   }
  public boolean retainAll(Collection<?> c) { return s.retainAll(c);   }
  public Object[] toArray()          { return s.toArray();  }
  public <T> T[] toArray(T[] a)      { return s.toArray(a); }
  @Override public boolean equals(Object o) { return s.equals(o);  }
  @Override public int hashCode()    { return s.hashCode(); }
  @Override public String toString() { return s.toString(); }
}
複製程式碼

SetWrapper 實現了裝飾模式，通過引用 Set<E> 型別的欄位，面向介面程式設計，相比直接繼承 HashSet 類來得更靈活。可以在呼叫該類的構造方法中傳入任意 Set 具體類。擴充套件該類以實現需求。

public class InstrumentedSet<E> extends SetWrapper<E> {
  private int addCount = 0;

  public InstrumentedSet(Set<E> s) {
    super(s);
  }

  @Override
  public boolean add(E e) {
    addCount++;
    return super.add(e);
  }

  @Override
  public boolean addAll(Collection<? extends E> c) {
    addCount += c.size();
    return super.addAll(c);
  }

  public int getAddCount() {
    return addCount;
  }
}
複製程式碼

舉一反三

注：以下程式碼均是虛擬碼，組合方式的實現待封裝成 Android 庫並開源，敬請期待。沒錯，這裡打了個廣告。

筆者曾開發的某個應用有以下2張截圖：

遊戲詳情頁面

評論列表頁面

詳情頁面和評論列表頁面均複用了評論項的實現。

評論列表頁面的 GameComentsAdapter。

public class GameCommentsAdapter extends RecyclerView.Adapter<BaseViewHolder> {
    private static final int ITEM_TYPE_COMMENT = 1;
    private List<Object> mDataSet;

    @Override
    public int getItemViewType(int position) {
        Object item = getItem(position);
        if (item instanceof Comment) {
            return ITEM_TYPE_COMMENT;
        }
        return super.getItemViewType(position);
    }

    protected Object getItem(int position) {
        return mDataSet.get(position);
    }

    @NonNull
    @Override
    public BaseViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        if (viewType == ITEM_TYPE_COMMENT) {
            View itemView = inflater.inflate(R.layout.item_comment, parent, false);
            return new CommentViewHolder(itemView);
        }
        return null;
    }

    @Override
    public int getItemCount() {
        return mDataSet.size();
    }
}
複製程式碼

if-else 方式實現

修改 GameComentsAdapter 類，增加對遊戲詳情項的適配支援。

public class GameCommentsAdapter extends RecyclerView.Adapter<BaseViewHolder> {
    private static final int ITEM_TYPE_COMMENT = 1;
    private static final int ITEM_TYPE_GAME_DETAIL = 2;
    private List<Object> mDataSet;

    @Override
    public int getItemViewType(int position) {
        Object item = getItem(position);
        if (item instanceof Comment) {
            return ITEM_TYPE_COMMENT;
        }
        if (item instanceof GameDetail) {
            return ITEM_TYPE_GAME_DETAIL;
        }
        return super.getItemViewType(position);
    }

    protected Object getItem(int position) {
        return mDataSet.get(position);
    }

    @NonNull
    @Override
    public BaseViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        if (viewType == ITEM_TYPE_COMMENT) {
            View itemView = inflater.inflate(R.layout.item_comment, parent, false);
            return new CommentViewHolder(itemView);
        }
        if (viewType == ITEM_TYPE_GAME_DETAIL) {
            View itemView = inflater.inflate(R.layout.item_game_detail, parent, false);
            return new GameDetailViewHolder(itemView);
        }
        return null;
    }

    @Override
    public int getItemCount() {
        return mDataSet.size();
    }
}
複製程式碼

在遊戲詳情頁面為 RecyclerView 建立一個 GameCommentsAdapter 物件。但該方式會讓 GameCommentsAdapter 變得臃腫，也不滿足OCP開閉原則。

繼承方式實現

擴充套件一個 Adapter 至少要實現 getItemViewType()、onCreateViewHolder() 等方法，為了複用 GameComentsAdapter 類中對評論項，詳情頁面的 GameDetailAdapter 繼承該類。

class GameDetailAdapter extends GameCommentsAdapter {
    private static final int ITEM_TYPE_GAME_DETAIL = 2;

    @Override
    public int getItemViewType(int position) {
        Object item = getItem(position);
        if (item instanceof GameDetail) {
            return ITEM_TYPE_GAME_DETAIL;
        }
        return super.getItemViewType(position);
    }

    @NonNull
    @Override
    public BaseViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        if (viewType == ITEM_TYPE_GAME_DETAIL) {
            LayoutInflater inflater = LayoutInflater.from(parent.getContext());
            View itemView = inflater.inflate(R.layout.item_game_detail, parent, false);
            return new GameDetailViewHolder(itemView);
        }
        return super.onCreateViewHolder(parent, viewType);
    }
}
複製程式碼

突然來了一個新需求

產品希望在詳情頁面新增推薦項，複用首頁列表項，如下圖所示：

首頁

實現效果如下圖所示：

詳情頁面增加

Java 是單繼承的，GameDetailAdapter 已經繼承了 GameComentsAdapter 類了，無法再繼承 HomeAdapter。

難道繼續在 GameComentsAdapter 類中增加 if 判斷？

組合方式

先把各個列表項的建立、繫結等抽離出來，引入 Subadapter 類。

interface Subadapter {
    boolean isFor(Object item);
    int getLayoutId();
    BaseViewHolder onCreateViewHolder(View itemView);
}
複製程式碼

實現 CommentSubadapter。

class CommentSubadapter implements Subadapter {

    @Override
    public boolean isFor(Object item) {
        return item instanceof Comment;
    }

    @Override
    public int getLayoutId() {
        return R.layout.item_comment;
    }

    @Override
    public BaseViewHolder onCreateViewHolder(View itemView) {
        return new CommentViewHolder(itemView);
    }
}
複製程式碼

實現 GameDetailSubadapter。

class GameDetailSubadapter implements Subadapter {

    @Override
    public boolean isFor(Object item) {
        return item instanceof GameDetail;
    }

    @Override
    public int getLayoutId() {
        return R.layout.item_game_detail;
    }

    @Override
    public BaseViewHolder onCreateViewHolder(View itemView) {
        return new GameDetailViewHolder(itemView);
    }
}
複製程式碼

實現 SubadapterManager。

class SubadapterManager {

    private SparseArray<Subadapter> mSubadapters = new SparseArray<>();

    public void addSubadapter(int itemType, Subadapter subadapter) {
        mSubadapters.put(itemType, subadapter);
    }

    public int getItemViewType(Object item) {
        for (int i = 0; i < mSubadapters.size(); i++) {
            Subadapter subadapter = mSubadapters.get(i);
            if (subadapter.isFor(item)) {
                return mSubadapters.keyAt(i);
            }
        }
        return 0;
    }

    public BaseViewHolder onCreateViewHolder(ViewGroup parent, int type) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        Subadapter subadapter = mSubadapters.get(type);
        View itemView = inflater.inflate(subadapter.getLayoutId(), parent, false);
        return subadapter.onCreateViewHolder(itemView);
    }
}
複製程式碼

實現唯一的 Adapter。

class Adapter extends RecyclerView.Adapter<BaseViewHolder> {
    private List<Object> mDataSet;
    private SubadapterManager mSubadapterManager;

    protected Object getItem(int position) {
        return mDataSet.get(position);
    }

    public void addSubadapter(int itemType, Subadapter subadapter) {
        mSubadapterManager.addSubadapter(itemType, subadapter);
    }

    @Override
    public int getItemViewType(int position) {
        Object item = getItem(position);
        return mSubadapterManager.getItemViewType(item);
    }

    @NonNull
    @Override
    public BaseViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        return mSubadapterManager.onCreateViewHolder(parent, viewType);
    }

    @Override
    public void onBindViewHolder(@NonNull BaseViewHolder holder, int position) {
        holder.bind(getItem(position));
    }

    @Override
    public int getItemCount() {
        return mDataSet.size();
    }

    public void setDataSet(List<Object> set) {
        mDataSet = set;
    }
}
複製程式碼

組合起來使用。在評論列表頁面，建立一個 Adapter 例項，並新增評論項功能。

List<Object> dataSet = new ArrayList<>();
dataSet.add(new Comment());
dataSet.add(new GameDetail());

Adapter adapter = new Adapter();
adapter.addSubadapter(ITEM_TYPE_COMMENT, new CommentSubadapter());
adapter.addSubadapter(ITEM_TYPE_GAME_DETAIL, new GameDetailSubadapter());
adapter.setDataSet(dataSet);
複製程式碼

實現 GameSubadapter 完成新需求。

class GameSubadapter implements Subadapter {
    @Override
    public boolean isFor(Object item) {
        return item instanceof Game;
    }

    @Override
    public int getLayoutId() {
        return R.layout.item_game;
    }

    @Override
    public BaseViewHolder onCreateViewHolder(View itemView) {
        return new GameViewHolder(itemView);
    }
}
複製程式碼

在遊戲詳情頁面，建立一個 Adapter 例項，並新增遊戲項功能。

List<Object> dataSet = new ArrayList<>();
dataSet.add(new Comment());
dataSet.add(new GameDetail());
dataSet.add(new Game());

Adapter adapter = new Adapter();
adapter.addSubadapter(ITEM_TYPE_COMMENT, new CommentSubadapter());
adapter.addSubadapter(ITEM_TYPE_GAME_DETAIL, new GameDetailSubadapter());
adapter.addSubadapter(ITEM_TYPE_GAME, new GameSubadapter());
adapter.setDataSet(dataSet);
複製程式碼

當某個頁面不再支援評論項時，我們只要刪除以下程式碼即可，不會修改到其他地方，滿足OCP設計原則。

dataSet.add(new Comment());
adapter.addSubadapter(ITEM_TYPE_COMMENT, new CommentSubadapter());
複製程式碼

延伸

在 Java 生態圈之外，有不少組合優於繼承的實踐。

Kotlin

Kotlin 語言有 delegation 機制，可以方便開發者使用組合。

interface Base {
   fun print()
}

class BaseImpl(val x: Int) : Base {
   override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
   val b = BaseImpl(10)
   Derived(b).print()
}
複製程式碼

Kotlin 版 InstrumentedHashSet

class InstrumentedHashSet<E>(val set: MutableSet<E>)
    : MutableSet<E> by set {

    private var addCount : Int = 0

    override fun add(element: E): Boolean {
        addCount++
        return set.add(element)
    }

    override fun addAll(elements: Collection<E>): Boolean {
        addCount += elements.size
        return set.addAll(elements)
    }
}
複製程式碼

Go

Go 語言沒有繼承機制，通過原生支援組合來實現程式碼的複用。以下分別是 Reader 和 Writer 介面定義。

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Writer interface {
	Write(p []byte) (n int, err error)
}
複製程式碼

通過組合可以定義出具備讀取和寫入的新型別。

type ReadWriter interface {
	Reader
	Writer
}
複製程式碼

上述的例子是介面組合，也可以是實現組合。(下面的例子來自 Go in Action 一書)

type user struct {
	name  string
	email string
}

// notify implements a method that can be called via
// a value of type user.
func (u *user) notify() {
	fmt.Printf("Sending user email to %s<%s>\n",
		u.name,
		u.email)
}

// admin represents an admin user with privileges.
type admin struct {
	user  // Embedded Type
	level string
}

// main is the entry point for the application.
func main() {
	// Create an admin user.
	ad := admin{
		user: user{
			name:  "john smith",
			email: "[email protected]",
		},
		level: "super",
	}

	// We can access the inner type's method directly.
	ad.user.notify()

	// The inner type's method is promoted.
	ad.notify()
}
複製程式碼

推薦書籍

參考資料

相關推薦

Effective Java 第三版——18. 組合優於繼承

封裝 view pub instant 基於 sna oar 對象 之一 Tips 《Effective Java, Third Edition》一書英文版已經出版，這本書的第二版想必很多人都讀過，號稱Java四大名著之一，不過第二版2009年出版，到現在已經將近8年的時

組合優於繼承

《Effective Java 中文版第2版》書中第16條中說到： 繼承是實現程式碼複用的有力手段，但它並非永遠是完成這項工作的的最佳工具。 組合優於繼承。 繼承有什麼問題？ 繼承打破了類的封裝性，子類依賴於父類中特定功能的實現細節。 繼承什麼時候是安全的 在包的內部是用繼承，不存

Effective Java 3rd 條目18 組合優於繼承

繼承是取得程式碼複用的一種強大方式，但是對於這項工作它不總是最好的工具。如果使用不恰當，那麼這將導致脆落的軟體。在一個包裡面使用繼承是安全的，包裡面的子類和超類實現是在同一個程式設計師的控制之下。當特意為擴充套件而設計和文件化的類(條目19)時，使用繼承也是安全的。跨包界線繼承普通具體類，無

JAVA基礎之設計模式中的組合優於繼承

a. 程式碼在多個子類中重複; b. 執行時的行為不容易改變； c. 改變會牽一髮動全身，造成部分子型別不想要的改變； 問題提出 當修改超類（父類）時，無論是新增還是刪除，對於子類的影響都是非常大的，例如說定義了鴨子類， 然後有野鴨子、綠毛鴨、橡皮鴨。 我們

java-組合優於繼承

組合和繼承，都能實現對類的擴充套件。 區別如下表所示 組合 繼承 has-a關係 is-a關係 執行期決定 編譯期決定 不破壞封裝，整體和區域性鬆耦合 破壞封裝，子類依賴父類 支援擴充套件，隨意增加

day31 類的組合及繼承，文件目錄規範

rop false 飛機 true img mod 之路 put ... Python之路，Day18 = Python基礎18-面向對象繼承與組合 類的繼承 1 def talk(): 2 print("I am come from talk..a")

python開發面向對象基礎：組合&繼承

ges agg odi 每次 git class 動作 take 判斷 一，組合 組合指的是，在一個類中以另外一個類的對象作為數據屬性，稱為類的組合 人類裝備了武器類就是組合 1.圓環，將圓類實例後傳給圓環類 1 #!/usr/bin/env python

Python學習之旅—面向對象進階知識：類的命名空間，類的組合與繼承

ati error role ont 之前 obj say 報錯 抽象 前言 　　上篇博客筆者帶領大家初步梳理了Python面向對象的基礎知識，本篇博客將專註於解決三個知識點：類的命名空間，類的組合以及面向對象的三大特性之一繼承，一起跟隨筆者老看看今天的內容吧。 1.

python自動化_day6_面向對象_組合，繼承，多態

基本 只需要 self. pytho super() width 搜索路徑 顯示 發生 復習：http://www.cnblogs.com/Eva-J/articles/7228075.html 模塊 1 import collections,os,sys,re,ran

遞歸函數、二分查找、面相對象初識、類空間，對象空間、組合、繼承

二分查找 tar %s anim style nim index 訪問類 AI 一、遞歸函數 一般遞歸100多次，都沒有解決的問題，放棄遞歸。 默認遞歸深度：998 修改默認遞歸次數 import sys sys.setrecursionlimit(100000)

C++網易雲課堂開發工程師--組合與繼承

一個 turn component 完成 tro 關系 pac pro art 著一個章節主要圍繞：繼承，復合，委托三個方面進行介紹。 復合：表示has-a template<class T, class Sequence = deque<T>>

閱讀隨筆之組合與繼承

組合：（has-a）將一個物件的引用置於新的物件中。（這是我自己的解釋，不是專業術語） 繼承：（is-a）繼承不是複製基類的介面，當你建立一個匯出類的物件時，該物件包含了一個基類的子物件。這個子物件與你直接建立物件是一樣的。二者的區別在於，後者來自於外部，而基類的子物件被包裝在匯出類物件內部。

複用-組合、繼承、代理區別和用法

繼承主要有兩個作用： 1.為匯出類提供方法，這個特性在程式碼複用有比較多的應用 2.表現匯出類與基類之間的關係。這個特性在多型裡非常有用，後面會講到。 我們先來講為匯出類提供方法這個特性——繼承是程式碼複用中重要的一種方式，很難把它與複用割裂開看，而且放在一起比較似乎更容易理解繼承在為匯出類

設計模式必須要弄明白的組合和繼承

前言 ​ 哇，最近再看Java程式設計思想，看到了第七章複用類中7.5在組合和繼承之間選擇。讓我對組合和繼承有了新的認知，前一段時間把設計模式看完了，雖然說看了幾遍，但是思想永遠的記不住，理解不了。但是今天，結合著組合和繼承讓我有了新的認知，故想給學設計模式的同學一個我的理解思路。 組合和繼承 理

python類與物件的組合與繼承

1、把類的物件例項化放到一個新的類裡面叫做類的組合，組合就是指幾個橫向關係的類放在一起，縱向關係的類放在一起是繼承，根據實際應用場景確定。簡單的說，組合用於“有一個”的場景中，繼承用於“是一個”的場景中。例如，水池裡有一個烏龜，天上有一個鳥，地上有一個小甲魚，這些適合使用組合。青瓜是瓜，女人是人，鯊魚是魚，這

組合和繼承有什麼區別？

組合和繼承是面向物件中兩種程式碼複用的方式。 1.組合定義 在新類裡面建立原有類的物件，重複利用已有類的功能。(has-a關係) 2.繼承定義 可以使用現有類的功能，並且在無需重複編寫原有類的情況下對原有類進行功能上的擴充套件。(is-a關係) 3.例項比較

Java筆記：組合、繼承

Java組合、繼承 組合 為達到同時使用幾個類的方法，可以採用組合的方法。就是將幾個類的方法例項化成物件，並變為另一個類的成員。為實現某個功能，可直接在其他區域呼叫此類中的物件的方法（需注意訪問限定符）；或在此類的public方法中呼叫其成員的方法，引數由大類方

組合，繼承，多型，封裝，反射，包裝，授權

組合 當類之間有顯著不同，並且較小的類是較大的類所需要的元件時，用組合比較好 class School(): def __init__(self,name,addr): self.name = name self.addr = addr

python學習（十五）——靜態、組合、繼承

一、靜態 1、靜態屬性-就是資料屬性 # 跟例項繫結，可以訪問例項屬性也可以訪問類屬性 class Room: def __init__(self,name,owner,width,length,heigh): tag = 1 se

Java類的組合與繼承 小問題分析（建構函式引數的傳遞方法 、資料隱藏的處理： 對比C++）

一、類的組合：     1、初始化問題（建構函式的引數傳遞方法）：       在C++中，通常只要物件中不含有指標類資料的話，物件與物件之間是可以相互賦值且不會出錯的，因此組合出來的類完全可以將傳遞過來的物件引數直接賦值給對應資料成員；       而在java中，物