结构模式--之--合成模型模式

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

 

抽象构件（Component）角色：抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为。

树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。

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

 

可以看出，Composite类型的对象含有其他的Component类型的对象。换言之，Composite类型的对象可以含有其他的树枝（Composite）类型或树叶（Leaf）类型的对象。

 

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

 

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

 

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

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

3个角色：

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

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

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

 

就以画图为例，画一个基本图形可以认为是一个叶子结点，而复杂图画则是由基本图形组成的，以合成模式示例代码如下：

public class NotSafeComposite {
    
    public static void main(String[] args) {
        Graph pic = new Picture();
        pic.add(new Line());
        pic.add(new RectAngle());
        
        pic.draw();
    }
}

//抽象构件
interface Graph{
    public void draw();
    public void add(Graph g);
    public void remove(Graph G);
    public Graph getChild(int i);
}
//树枝构件
class Picture implements Graph{
    private List<Graph> list = new ArrayList<Graph>();
    @Override
    public void draw() {
        for(int i=0;i<list.size();i++){
            Graph g = list.get(i);
            g.draw();
        }
    }

    @Override
    public void add(Graph g) {
        list.add(g);
    }

    @Override
    public void remove(Graph g) {
        list.remove(g);
    }

    @Override
    public Graph getChild(int i) {
        return list.get(i);
    }
    
}

//树叶构件
class Line implements Graph{

    @Override
    public void draw() {
        System.out.println("Draw a line --------------");
    }

    @Override
    public void add(Graph g) {
        
    }

    @Override
    public void remove(Graph G) {
        
    }

    @Override
    public Graph getChild(int i) {
        return null;
    }
    
}

//树叶构件
class RectAngle implements Graph{

    @Override
    public void draw() {
        System.out.println("Draw a RectAngle   --||");
    }

    @Override
    public void add(Graph g) {
        
    }

    @Override
    public void remove(Graph G) {
        
    }

    @Override
    public Graph getChild(int i) {
        return null;
    }
    
}

 

 

 

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

 

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

这种形式有3 个角色：

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

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

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

 

 

public class SafeComposite {
    
    public static void main(String[] args) {
        Picture picture = new Picture();
        picture.add(new Line());
        picture.add(new RectAngle());
        picture.draw();
    }
}
//抽象构件
interface Graph{
    public void draw();
}

//树枝构件
class Picture implements Graph{
    private List<Graph> list = new ArrayList<Graph>();
    @Override
    public void draw() {
        for(int i=0;i<list.size();i++){
            Graph g = list.get(i);
            g.draw();
        }
    }
    
    public void add(Graph g){
        list.add(g);
    }
    
    public void remove(Graph g){
        list.remove(g);
    }
    //返回一个子构件对象
    public Graph getChild(int i){
        return list.get(i);
    }
}

//树叶构件 
class Line implements Graph{

    @Override
    public void draw() {
        System.out.println("Draw a line-----------------------");
    }
    
}

//树叶构件
class RectAngle implements Graph{

    @Override
    public void draw() {
        System.out.println("Draw a Rect --|||");
    }
    
}

 

 

-----

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

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

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

它的优点是：

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

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

合成模式的缺点是：

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

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