本文共 6803 字，大约阅读时间需要 22 分钟。

Java设计模式 —— 组合模式(Composite)

定义

Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。

特征：

1. 树形结构，节点如果没有分支，就是叶子节点；如果存在分支，则是树枝节点
2. 关键在于它定义了一个抽象构建类，它既可表示叶子对象，也可表示容器对象。就是树枝和叶子实现了统一接口，或树枝和叶子之间有继承关系
3. 根据所实现接口的区别分为两种形式，分别称为安全方式和透明方式。

代码实现

透明方式：树枝、叶子节点都提供子对象的管理方法，诸如：add()、remove()、以及getChild()等

抽象构件角色类

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
   
     getChild(){           /**         * 缺省实现，抛出异常，因为叶子对象没有此功能         * 或者子组件没有实现这个功能         */        throw new UnsupportedOperationException("对象不支持此功能");    }}
   

树枝构件角色类，此类将implements Conponent改为extends Conponent，其他地方无变化。

public class Composite extends Component {       /**     * 用来存储组合对象中包含的子组件对象     */    private List
   
     childComponents = new ArrayList
    
     ();    /**     * 组合对象的名字     */    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
     
       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对象。

安全方式：树枝都提供子对象的管理方法，叶子节点不提供；也就是抽象类中没有管理方法函数的声明

抽象构件角色类

public interface Component {       /**     * 输出组建自身的名称     */    public void printStruct(String preStr);}

树枝构件角色类

public class Composite implements Component {       /**     * 用来存储组合对象中包含的子组件对象     */    private List
   
     childComponents = new ArrayList
    
     ();    /**     * 组合对象的名字     */    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
     
       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()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。这样的做法是安全的做法，由于这个特点，客户端应用程序不可能错误地调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译错误。

安全式合成模式的缺点是不够透明，因为树叶类和树枝类将具有不同的接口。

组合模式使用问题

优点： 1、高层模块调用简单。 2、节点自由增加。3、客户端可以一致的使用组合结构或其中单个对象。就像Linux一切皆文件。

缺点：

1、在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

2、使设计变得更加抽象，对象的业务规则如果很复杂，则实现组合模式具有很大挑战性，而且不是所有的方法都与叶子对象子类都有关联，会有冗余代码

Android中组合模式

Android源码中，ViewGroup 和 View 就是典型的组合模式。

View相当与叶子节点，里面没有添加删除View等操作。

感谢

segmentfault: