引入

在阎宏博士的《JAVA与模式》一书中开头是这样描述合成（Composite）模式（组合模式）的：

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

---

定义

组合模式组合多个对象形成树形结构以表示“整体-部分”的结构层次。

组合模式对单个对象(叶子对象)和组合对象(组合对象)具有一致性，它将对象组织到树结构中，可以用来描述整体与部分的关系。同时它也模糊了简单元素(叶子对象)和复杂元素(容器对象)的概念，使得客户能够像处理简单元素一样来处理复杂元素，从而使客户程序能够与复杂元素的内部结构解耦。

组合模式把部分和整体的关系用树结构表示出来。组合模式使得客户端把一个个单独的成分对象和由它们复合而成的合成对象同等看待。

比如，一个文件系统就是一个典型的组合模式系统。下图是常见的计算机XP文件系统的一部分。

从上图可以看出，文件系统是一个树结构，树上长有节点。树的节点有两种，一种是树枝节点，即目录，有内部树结构，在图中涂有颜色；另一种是文件，即树叶节点，没有内部树结构。

显然，可以把目录和文件当做同一种对象同等对待和处理，这也就是组合模式的应用。

组合模式可以不提供父对象的管理方法，但是组合模式必须在合适的地方提供子对象的管理方法，诸如：add()、remove()、以及getChild()等。在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

组合模式的实现根据所实现接口的区别分为两种形式，分别称为安全式和透明式。

---

结构和代码实现

安全式组合模式

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

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

• 抽象构件(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 前缀，主要是按照层级拼接空格，实现向后缩进*/@Overridepublic 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 前缀，主要是按照层级拼接的空格，实现向后缩进*/@Overridepublic void printStruct(String preStr) {// TODO Auto-generated method stubSystem.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()等方法的声明和实现，而树叶构件类则没有给出这些方法的声明或实现。这样的做法是安全的做法，由于这个特点，客户端应用程序不可能错误地调用树叶构件的聚集方法，因为树叶构件没有这些方法，调用会导致编译错误。

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

透明式组合模式

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

代码实现
抽象构件角色类

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 前缀，主要是按照层级拼接空格，实现向后缩进*/@Overridepublic 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 前缀，主要是按照层级拼接的空格，实现向后缩进*/@Overridepublic void printStruct(String preStr) {// TODO Auto-generated method stubSystem.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对象，具体的类型对于客户端而言是透明的，是无须关心的。

对于组合模式而言，在安全性和透明性上，会更看重透明性，毕竟组合模式的目的是：让客户端不再区分操作的是树枝对象还是树叶对象，而是以一个统一的方式来操作。

而且对于安全性的实现，需要区分是树枝对象还是树叶对象。有时候，需要将对象进行类型转换，却发现类型信息丢失了，只好强行转换，这种类型转换必然是不够安全的。

因此在使用组合模式的时候，建议多采用透明性的实现方式。

优点

1. 可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件也更容易。
2. 客户端调用简单，客户端可以一致的使用组合结构或其中单个对象。
3. 定义了包含叶子对象和容器对象的类层次结构，叶子对象可以被组合成更复杂的容器对象，而这个容器对象又可以被组合，这样不断递归下去，可以形成复杂的树形结构。
4. 更容易在组合体内加入对象构件，客户端不必因为加入了新的对象构件而更改原有代码。

缺点

1. 使设计变得更加抽象，对象的业务规则如果很复杂，则实现组合模式具有很大挑战性，而且不是所有的方法都与叶子对象子类都有关联。 适用场景
2. 需要表示一个对象整体或部分层次，在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，可以一致地对待它们。
3. 让客户能够忽略不同对象层次的变化，客户端可以针对抽象构件编程，无须关心对象层次结构的细节。

总结

1. 组合模式用于将多个对象组合成树形结构以表示“整体-部分”的结构层次。组合模式对单个对象（叶子对象）和组合对象（容器对象）的使用具有一致性。
2. 组合对象的关键在于它定义了一个抽象构建类，它既可表示叶子对象，也可表示容器对象，客户仅仅需要针对这个抽象构建进行编程，无须知道他是叶子对象还是容器对象，都是一致对待。
3. 组合模式虽然能够非常好地处理层次结构，也使得客户端程序变得简单，但是它也使得设计变得更加抽象，而且也很难对容器中的构件类型进行限制，这会导致在增加新的构件时会产生一些问题。