一、基本概念

合成模式屬于物件的結構模式，有時又叫做“部分——整體”模式，合成模式將物件組織到樹結構中，可以用來描述整體與部分的關系，合成模式可以使客戶端將單純元素與復合元素同等看待，

二、通俗解釋

COMPOSITE合成模式：Mary今天過生日，“我過生日，你要送我一件禮物，”“嗯，好吧，去商店，你自己挑，”“這件T恤挺漂亮，買，這條裙子好看，買，這個包也不錯，買，”“喂，買了三件了呀，我只答應送一件禮物的哦，”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻煩你包起來，”“……”，MM都會用Composite模式了，你會了沒有？合成模式：合成模式將物件組織到樹結構中，可以用來描述整體與部分的關系，合成模式就是一個處理物件的樹結構的模式，合成模式把部分與整體的關系用樹結構表示出來，合成模式使得客戶端把一個個單獨的成分物件和由他們復合而成的合成物件同等看待，

檔案系統例子：

合成模式把部分和整體的關系用樹結構表示出來，合成模式使得客戶端把一個個單獨的成分物件和由它們復合而成的合成物件同等看待，比如，一個檔案系統就是一個典型的合成模式系統，下圖是常見的計算機XP檔案系統的一部分，

從上圖可以看出，檔案系統是一個樹結構，樹上長有節點，樹的節點有兩種，一種是樹枝節點，即目錄，有內部樹結構，在圖中涂有顏色；另一種是檔案，即樹葉節點，沒有內部樹結構，

顯然，可以把目錄和檔案當做同一種物件同等對待和處理，這也就是合成模式的應用，

合成模式可以不提供父物件的管理方法，但是合成模式必須在合適的地方提供子物件的管理方法，諸如：add()、remove()、以及getChild()等，

三、分類

合成模式的實作根據所實作介面的區別分為兩種形式，分別稱為安全式和透明式，

1.安全式合成模式的結構

安全模式的合成模式要求管理聚集的方法只出現在樹枝構件類中，而不出現在樹葉構件類中，

這種形式涉及到三個角色：

　●　抽象構件(Component)角色：這是一個抽象角色，它給參加組合的物件定義出公共的介面及其默認行為，可以用來管理所有的子物件，合成物件通常把它所包含的子物件當做型別為Component的物件，在安全式的合成模式里，構件角色并不定義出管理子物件的方法，這一定義由樹枝構件物件給出，

　●　樹葉構件(Leaf)角色：樹葉物件是沒有下級子物件的物件，定義出參加組合的原始物件的行為，

　●　樹枝構件(Composite)角色：代表參加組合的有下級子物件的物件，樹枝構件類給出所有的管理子物件的方法，如add()、remove()以及getChild()，

抽象構件角色類

public interface Component {
    /**
     * 輸出組建自身的名稱
     */
    public void printStruct(String preStr);
}

樹枝構件角色類

public class Composite implements Component {
    /**
     * 用來存盤組合物件中包含的子組件物件
     */
    private List<Component> childComponents = new ArrayList<Component>();
    /**
     * 組合物件的名字
     */
    private String name;
    /**
     * 構造方法，傳入組合物件的名字
     * @param name    組合物件的名字
     */
    public Composite(String name){
        this.name = name;
    }
    /**
     * 聚集管理方法，增加一個子構件物件
     * @param child 子構件物件
     */
    public void addChild(Component child){
        childComponents.add(child);
    }
    /**
     * 聚集管理方法，洗掉一個子構件物件
     * @param index 子構件物件的下標
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }
    /**
     * 聚集管理方法，回傳所有子構件物件
     */
    public List<Component> getChild(){
        return childComponents;
    }
    /**
     * 輸出物件的自身結構
     * @param preStr 前綴，主要是按照層級拼接空格，實作向后縮進
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己輸出
        System.out.println(preStr + "+" + this.name);
        //如果還包含有子組件，那么就輸出這些子組件物件
        if(this.childComponents != null){
            //添加兩個空格，表示向后縮進兩個空格
            preStr += "  ";
            //輸出當前物件的子物件
            for(Component c : childComponents){
                //遞回輸出每個子物件
                c.printStruct(preStr);
            }
        }        
    }
}

樹葉構件角色類

public class Leaf implements Component {
    /**
     * 葉子物件的名字
     */
    private String name;
    /**
     * 構造方法，傳入葉子物件的名稱
     * @param name 葉子物件的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 輸出葉子物件的結構，葉子物件沒有子物件，也就是輸出葉子物件的名字
     * @param preStr 前綴，主要是按照層級拼接的空格，實作向后縮進
     */
    @Override
    public void printStruct(String preStr) {
        // TODO Auto-generated method stub
        System.out.println(preStr + "-" + name);
    }
}

客戶端類

public class Client {
    public static void main(String[]args){
        Composite root = new Composite("服裝");
        Composite c1 = new Composite("男裝");
        Composite c2 = new Composite("女裝");
        
        Leaf leaf1 = new Leaf("襯衫");
        Leaf leaf2 = new Leaf("夾克");
        Leaf leaf3 = new Leaf("裙子");
        Leaf leaf4 = new Leaf("套裝");
        
        root.addChild(c1);
        root.addChild(c2);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c2.addChild(leaf3);
        c2.addChild(leaf4);
        
        root.printStruct("");
    }
}

可以看出，樹枝構件類(Composite)給出了addChild()、removeChild()以及getChild()等方法的宣告和實作，而樹葉構件類則沒有給出這些方法的宣告或實作，這樣的做法是安全的做法，由于這個特點，客戶端應用程式不可能錯誤地呼叫樹葉構件的聚集方法，因為樹葉構件沒有這些方法，呼叫會導致編譯錯誤，

安全式合成模式的缺點是不夠透明，因為樹葉類和樹枝類將具有不同的介面，

2.透明式合成模式的結構

與安全式的合成模式不同的是，透明式的合成模式要求所有的具體構件類，不論樹枝構件還是樹葉構件，均符合一個固定介面，

抽象構件角色類

public abstract class Component {
    /**
     * 輸出組建自身的名稱
     */
    public abstract void printStruct(String preStr);
    /**
     * 聚集管理方法，增加一個子構件物件
     * @param child 子構件物件
     */
    public void addChild(Component child){
        /**
         * 預設實作，拋出例外，因為葉子物件沒有此功能
         * 或者子組件沒有實作這個功能
         */
        throw new UnsupportedOperationException("物件不支持此功能");
    }
    /**
     * 聚集管理方法，洗掉一個子構件物件
     * @param index 子構件物件的下標
     */
    public void removeChild(int index){
        /**
         * 預設實作，拋出例外，因為葉子物件沒有此功能
         * 或者子組件沒有實作這個功能
         */
        throw new UnsupportedOperationException("物件不支持此功能");
    }
    
    /**
     * 聚集管理方法，回傳所有子構件物件
     */
    public List<Component> getChild(){
        /**
         * 預設實作，拋出例外，因為葉子物件沒有此功能
         * 或者子組件沒有實作這個功能
         */
        throw new UnsupportedOperationException("物件不支持此功能");
    }
}

樹枝構件角色類，此類將implements Conponent改為extends Conponent，其他地方無變化，

public class Composite extends Component {
    /**
     * 用來存盤組合物件中包含的子組件物件
     */
    private List<Component> childComponents = new ArrayList<Component>();
    /**
     * 組合物件的名字
     */
    private String name;
    /**
     * 構造方法，傳入組合物件的名字
     * @param name    組合物件的名字
     */
    public Composite(String name){
        this.name = name;
    }
    /**
     * 聚集管理方法，增加一個子構件物件
     * @param child 子構件物件
     */
    public void addChild(Component child){
        childComponents.add(child);
    }
    /**
     * 聚集管理方法，洗掉一個子構件物件
     * @param index 子構件物件的下標
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }
    /**
     * 聚集管理方法，回傳所有子構件物件
     */
    public List<Component> getChild(){
        return childComponents;
    }
    /**
     * 輸出物件的自身結構
     * @param preStr 前綴，主要是按照層級拼接空格，實作向后縮進
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己輸出
        System.out.println(preStr + "+" + this.name);
        //如果還包含有子組件，那么就輸出這些子組件物件
        if(this.childComponents != null){
            //添加兩個空格，表示向后縮進兩個空格
            preStr += "  ";
            //輸出當前物件的子物件
            for(Component c : childComponents){
                //遞回輸出每個子物件
                c.printStruct(preStr);
            }
        }        
    }
}

樹葉構件角色類，此類將implements Conponent改為extends Conponent，其他地方無變化，

public class Leaf extends Component {
    /**
     * 葉子物件的名字
     */
    private String name;
    /**
     * 構造方法，傳入葉子物件的名稱
     * @param name 葉子物件的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 輸出葉子物件的結構，葉子物件沒有子物件，也就是輸出葉子物件的名字
     * @param preStr 前綴，主要是按照層級拼接的空格，實作向后縮進
     */
    @Override
    public void printStruct(String preStr) {
        // TODO Auto-generated method stub
        System.out.println(preStr + "-" + name);
    }
}

客戶端類的主要變化是不再區分Composite物件和Leaf物件，

public class Client {
    public static void main(String[]args){
        Component root = new Composite("服裝");
        Component c1 = new Composite("男裝");
        Component c2 = new Composite("女裝");
        
        Component leaf1 = new Leaf("襯衫");
        Component leaf2 = new Leaf("夾克");
        Component leaf3 = new Leaf("裙子");
        Component leaf4 = new Leaf("套裝");
        
        root.addChild(c1);
        root.addChild(c2);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c2.addChild(leaf3);
        c2.addChild(leaf4);
        
        root.printStruct("");
    }
}

可以看出，客戶端無需再區分操作的是樹枝物件(Composite)還是樹葉物件(Leaf)了；對于客戶端而言，操作的都是Component物件，

四、兩種實作方法的選擇

　　這里所說的安全性合成模式是指：從客戶端使用合成模式上看是否更安全，如果是安全的，那么就不會有發生誤操作的可能，能訪問的方法都是被支持的，

　　這里所說的透明性合成模式是指：從客戶端使用合成模式上，是否需要區分到底是“樹枝物件”還是“樹葉物件”，如果是透明的，那就不用區分，對于客戶而言，都是Compoent物件，具體的型別對于客戶端而言是透明的，是無須關心的，

　　對于合成模式而言，在安全性和透明性上，會更看重透明性，畢竟合成模式的目的是：讓客戶端不再區分操作的是樹枝物件還是樹葉物件，而是以一個統一的方式來操作，

　　而且對于安全性的實作，需要區分是樹枝物件還是樹葉物件，有時候，需要將物件進行型別轉換，卻發現型別資訊丟失了，只好強行轉換，這種型別轉換必然是不夠安全的，

　　因此在使用合成模式的時候，建議多采用透明性的實作方式，　

（參考：《JAVA與模式》之合成模式）

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/8571.html

標籤：設計模式

上一篇：談談Java常用類別庫中的設計模式 - Part Ⅰ