初識設計模式 - 組合模式

簡介

組合模式就是組合多個對象形成樹形結構以表示具有“部分 - 整體”關係的層次結構。組合模式對單個對象（葉子對象）和組合對象（容器對象）的使用具有一致性。

組合模式的關鍵是定義一個抽象構件類，它既可以代表葉子，也可以代表容器。客戶端針對該抽象構件進行編程，無需知道它到底表示的是葉子還是容器，可以對其進行統一處理。

具體實現

對於組合模式的抽象構件角色，其代碼示例如下：

public abstract class Component {
    // 增加成員
    public abstract void add(Component c);

    // 刪除成員
    public abstract void remove(Component c);

    // 獲取成員
    public abstract Component getChild(int i);

    // 業務方法
    public abstract void operation();
}

如果繼承抽象構件類的是葉子構件，其代碼示例如下：

public class Leaf extends Component {
    @Override
    public void add(Component c) {
        // 增加成員
        // 異常處理或業務提示
    }

    @Override
    public void remove(Component c) {
        // 刪除成員
        // 異常處理或業務提示
    }

    @Override
    public Component getChild(int i) {
        // 獲取成員
        // 異常處理或業務提示
    }

    @Override
    public void operation() {
        // 業務方法
        // 葉子構件具體業務方法的實現
    }
}

如果繼承抽象構件類的是容器構件，其代碼示例如下：

import java.util.ArrayList;

public class Composite extends Component {  
    private final ArrayList<Component> list = new ArrayList<>();  
  
    @Override  
    public void add(Component c) {  
        // 增加成員  
        list.add(c);  
    }  
  
    @Override  
    public void remove(Component c) {  
        // 刪除成員  
        list.remove(c);  
    }  
  
    @Override  
    public Component getChild(int i) {  
        // 獲取成員  
        return (Component) list.get(i);  
    }  
  
    @Override  
    public void operation() {  
        // 業務方法  
        // 葉子構件具體業務方法的實現  
        // 遞歸調用成員構件的業務方法  
        for (Component obj : list) {  
            obj.operation();  
        }  
    }  
}

分類

在使用組合模式時，根據抽象構件類的定義形式，可以將組合模式分為透明組合模式和安全組合模式兩種。

透明組合模式

在透明組合模式中，抽象構件類聲明瞭所有用於管理成員的方法，如 add()、remove()、getChild() 等所有方法。

透明組合模式也是組合模式的標準形式，這樣做的好處是確保所有的構件類都使用相同的介面。

其缺點就是不夠安全，因為葉子對象和容器對象有本質上的區別，對葉子對象提供 add()、remove()、getChild() 等方法是沒有意義的，如果沒有提供相應的錯誤處理代碼，在運行階段有可能會出錯。

安全組合模式

在安全組合模式中，抽象構件類沒有聲明任何管理成員的方法，只聲明抽象的業務方法。

這樣的做法是安全的，因為根本不向葉子對象提供這些管理成員對象的方法，對於葉子對象，客戶端不可能調用到這些方法。

相對的，其缺點就是不夠透明，因為葉子構件和容器構件具有不同的方法，客戶端不能完全針對抽象編程，必須有區別地對待葉子構件和容器構件。

總結

優點

組合模式的主要優點如下：

• 組合模式為樹形結構的面向對象實現提供了一種靈活的解決方案
• 在組合模式中增加新的葉子構件和容器構件都很方便，符合開閉原則
• 客戶端可以一致地使用一個組合結構或其中單個對象，簡化了客戶端代碼

缺點

組合模式的主要缺點如下：

• 設計較複雜，客戶端需要花費更多時間理清類之間的層次關係
• 在增加新構件時很難對容器中的構件類型進行限制，通常通過運行時進行類型檢查來實現

適用場景

組合模式的適用場景如下：

• 在具有整體和部分的層次結構中，希望通過一種方式忽略整體和部分的差異
• 在一個使用面向對象語言開發的系統中需要處理一個樹形結構

源碼

在 JDK 中，HashMap 也是用到了組合模式，如下是部分代碼：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }

    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            if (table == null) { // pre-size
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                if (t > threshold)
                    threshold = tableSizeFor(t);
            } else {
                // Because of linked-list bucket constraints, we cannot
                // expand all at once, but can reduce total resize
                // effort by repeated doubling now vs later
                while (s > threshold && table.length < MAXIMUM_CAPACITY)
                    resize();
            }

            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }
}

putAll() 和 putMapEntries() 都接受一個 Map 結構參數，這個 Map 就是一個抽象構件，HashMap 同樣是實現了 Map 結構，輕易實現一個樹形的調用結構。

首發於翔仔的個人博客，點擊查看更多。