合成模式

概述：

          合成模式属于对象的结构模式，有时叫部分-整体模式。合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素和复合元素同等看待。

安全式：

       在Composite类里声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。编译通不过，就不会出现运行时错误。这个缺点是中够透明，因为树叶类和合成类将具有不同的接口。

安全式的合成模式要求管理聚集的方法只出现在树枝构件类中，而不出现在树叶构件类中。

这种形式有3 个角色：

1.抽象构件（Component）角色：抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。合成对象通常把所包含的子对象当作类型为（Component）的对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。

2.树叶构件（Leaf）角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。

3.树枝构件（Composite）角色：代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如add(),remove()及components()的声明。

        

interface Component{
    Composite getComposite();
    void sampleOperation();
}
class Composite implements Component{

    private Vector componentVector = new Vector<>();
    
    @Override
    public Composite getComposite() {
        // TODO Auto-generated method stub
        return this;
    }

    @Override
    public void sampleOperation() {
        // TODO Auto-generated method stub
        Enumeration enumeration = componentVector.elements();
        while (enumeration.hasMoreElements()){
            ((Component)enumeration.nextElement()).sampleOperation();
        }
    }
    
    public void add(Component component){
        componentVector.addElement(component);
    }
    
    public void remove(Component component){
        componentVector.removeElement(component);
    }
}

class Leaf implements Component {

    @Override
    public Composite getComposite() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void sampleOperation() {
        // TODO Auto-generated method stub
        
    }
    
}

透明方式：在Component里面声明所有的用来管理子类对象的方法，包括add(),remove(),及getChild()方法。这样做的好处是所有构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别在接口层次消失了，客户端可以同等地对待所有的对象。这种方式缺点是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一个层次的对象，因此add()，remove()以及getChild()方法没有意义，但是在编译时不会出错，而只会在运行时出错

透明式的合成模式的结构：

与安全模式的合成模式不同的是：透明式的合成模式要求所有的具体构件类，不论树枝构件还是树叶构件，均符合一个固定的接口

抽象构件（Component）角色：它给参加组合的对象规定一个接口，规范共有的接口及默认行为。这个接口可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口，包括add(),remove(),及getChild()之类的方法。

树叶构件（Leaf）角色：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶会给出add(),remove(),及getChild()之类的用来管理子类对象的方法的平庸实现

树枝构件（Composite）角色：代表参加组合的有子对象的对象，定义出这样的对象的行为。

interface Component{
    Composite getComposite();
    void sampleOperation();
    void add(Component component);
    void remove(Component component);
}
class Composite implements Component{

    private Vector componentVector = new Vector<>();
    
    @Override
    public Composite getComposite() {
        // TODO Auto-generated method stub
        return this;
    }

    @Override
    public void sampleOperation() {
        // TODO Auto-generated method stub
        Enumeration enumeration = componentVector.elements();
        while (enumeration.hasMoreElements()){
            ((Component)enumeration.nextElement()).sampleOperation();
        }
    }
    
    public void add(Component component){
        componentVector.addElement(component);
    }
    
    public void remove(Component component){
        componentVector.removeElement(component);
    }
}

class Leaf implements Component {

    @Override
    public Composite getComposite() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void sampleOperation() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void add(Component component) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void remove(Component component) {
        // TODO Auto-generated method stub
        
    }
    
}

什么情况下使用合成模式？

1.需要描述对象的部分和整体的等级结构

2.需要客户端忽略掉个体构件和组合构件的区别。客户端必须平等对待所有的构件，包括个体构件和组合构件。

它的优点是：

1.合成模式可以很容易地增加新种类的构件

2.使用合成模式可以使客户端变得很容易设计，因为客户端不需要知道构件是树叶构件还是树枝构件

合成模式的缺点是：

1.使用合成模式后，控制树枝构件的类型就不太容易

2.用继承的方法来增加新的行为很困难。