合成模式（Composite）

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

安全式和透明式的合成模式

下图所示的类图略去了各个角色的细节，没有给出它们的各种方法

可以看出上面的类图结构涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为。
• 树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。
• 树枝构件（Composite）角色：代表参加组合的有子对象的对象，并给出树枝构件对象的行为。

合成模式的实现根据所实现接口的区别分为两种形式，分别称为安全式和透明式。合成模式可以不提供父对象的管理方法，但是合成模式必须在合适的地方提供子对象的管理方法。在什么地方声明子对象的管理方法，诸如add()、remove()以及getChild()等就变成了一个值得仔细思考的问题。

透明方式

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

安全方式

第二种选择是在Composite类里面声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。编译通不过，就不会出现运行时期的错误。
这个选择的缺点是不够透明，因为树叶类和合成类将具有不同的接口。
这两个形式各有优缺点，需要根据软件的具体情况做出取舍决定。

安全式的合成模式的结构

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

这种形式涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为，可以用来管理所有的子对象。合成对象通常把它所包含的子对象当作类型为Component的对象。在安全模式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
• 树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。
• 树枝构件（Composite）角色：代表参加组合的有子对象的对象。树枝构件类给出所有的管理子对象的方法，如add()、remove()以及components()等方法。其中components()方法就相当于getChilde()方法。

抽象构件角色Component的接口代码：

public interface Component
{
    /**
     * 返回自己的实例
     */
    Composite getComposite();

    /**
     * 某个商业方法
     */
    void sampleOperation();
}

树枝构件（Composite）类的源代码：

import java.util.Vector;
import java.util.Enumeration;

public class Composite implements Component
{
    private Vector componentVecotr = new java.util.Vector();

    /**
     * 返回自己的实例
     */
    public Composite getComposite()
    {
        return this;
    }

    /**
     * 某个商业方法
     */
    public void sampleOperation()
    {
        Enumeration enumeration = components();
        while(enumeration.hasMoreElements()) 
        {
            ((Component)enumeration.nextElement()).sampleOperation();
        }
    }

    /**
     * 聚集管理方法，增加一个子构件对象
     */
    public void add(Component component)
    {
        componentVector.addElement(component);
    }

    /**
     * 聚集管理方法，删除一个子构件对象
     */
    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }

    /**
     * 聚集管理方法，返回聚集的Enumeration对象
     */
    public Enumeration components()
    {
        return componentVector.elements();
    }
}

树叶构件(Leaf)类的源代码：

import java.util.Enumeration;

public class Leaf implements Component
{
    /**
     * 某个商业方法
     */
    public void sampleOperation()
    {
        //Write your code here
    }

    /**
     * 返回自己的实例
     */
    public Composite getComposite()
    {
        //Write your code here
        return null;
    }   
}

透明式的合成模式的结构

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

这种形式涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为，可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口，包括add()、remove()以及getChild()之类的方法。
• 树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。树叶类会给出add()、remove()以及getChild()之类的用来管理子类对象的方法的平庸实现。
• 树枝构件（Composite）角色：代表参加组合的有子对象的对象。树枝构件类给出所有的管理子对象的方法，如add()、remove()以及components()等方法。其中components()方法就相当于getChilde()方法。

抽象构件角色Component的接口代码：

public interface Component
{
    /**
     * 返回自己的实例
     */
    Composite getComposite();

    /**
     * 某个商业方法
     */
    void sampleOperation();

    /**
     * 聚集管理方法，增加一个子构件对象
     */
    public void add(Component component);

    /**
     * 聚集管理方法，删除一个子构件对象
     */
    public void remove(Component component);

    /**
     * 聚集管理方法，返回聚集的Enumeration对象
     */
    public Enumeration components();
}

树枝构件（Composite）类的源代码：

import java.util.Vector;
import java.util.Enumeration;

public class Composite implements Component
{
    private Vector componentVecotr = new java.util.Vector();

    /**
     * 返回自己的实例
     */
    public Composite getComposite()
    {
        return this;
    }

    /**
     * 某个商业方法
     */
    public void sampleOperation()
    {
        Enumeration enumeration = components();
        while(enumeration.hasMoreElements()) 
        {
            ((Component)enumeration.nextElement()).sampleOperation();
        }
    }

    /**
     * 聚集管理方法，增加一个子构件对象
     */
    public void add(Component component)
    {
        componentVector.addElement(component);
    }

    /**
     * 聚集管理方法，删除一个子构件对象
     */
    public void remove(Component component)
    {
        componentVector.removeElement(component);
    }

    /**
     * 聚集管理方法，返回聚集的Enumeration对象
     */
    public Enumeration components()
    {
        return componentVector.elements();
    }
}

树叶构件(Leaf)类的源代码：

import java.util.Enumeration;

public class Leaf implements Component
{
    /**
     * 某个商业方法
     */
    public void sampleOperation()
    {
        //Write your code here
    }

    /**
     * 返回自己的实例
     */
    public Composite getComposite()
    {
        //Write your code here
        return null;
    }   
    /**
     * 聚集管理方法，增加一个子构件对象
     */
    public void add(Component component)
    {

    }

    /**
     * 聚集管理方法，删除一个子构件对象
     */
    public void remove(Component component)
    {

    }

    /**
     * 聚集管理方法，返回聚集的Enumeration对象
     */
    public Enumeration components()
    {
        return null;
    }
}