合成模式又叫整体部分模式，是将对象组织到一个树的结构中，用来描述整体与部分的关系。换句话说，用树结构表示整体与部分，客户端对待整体和部分是一视同仁。
怎么理解这个树？一般情况子类继承父类，孙子类再继承儿子类，子子孙孙这样就能形成一个树的结构；另外一个情况是对象A的属性是一个对象B，对象 B 的属性又有对象 C，如此下去也形成一个树。
常见的文件系统目录结构就是一个树，也是合成模式的一种具体代表，我们在处理文件 API 的时候，目录和文件是同等对待。
合成模式的实现根据所实现接口的区别分为两种形式，分别称为安全式和透明式。
安全式合成模式
看下类图
基本上操作集中在树枝上面，树枝管理整个树的增删改查动作；而叶子节点不具备管理能力。
根角色提供抽象接口，在这里，根也不进行管理；
树枝角色提供管理能力；
叶子角色没有下级，只是参与被管理。
接下来看下代码的实现
首先定义一个根的接口
public interface Root {
public void print(String lvl);
}
把叶子节点给实现出来
public class Leaf implements Root{
private String name;//名称
public Leaf(String name){
this.name = name;
}
@Override
public void print(String lvl) {
System.out.println(lvl + "-" + name);
}
}
接下来实现树枝
public class Branch implements Root {
private List<Root> childComponents = new ArrayList<Root>();
private String name;
public Branch(String name){
this.name = name;
}
public void addChild(Root child){
childComponents.add(child);
}
public void removeChild(int index){
childComponents.remove(index);
}
public List<Root> getChild(){
return childComponents;
}
@Override
public void print(String preStr) {
System.out.println(preStr + "+" + this.name);
if(this.childComponents != null){
//向后缩进两个空格
preStr += " ";
for(Root c : childComponents){
c.print(preStr);
}
}
}
}
最后来测试一下
public class Client {
public static void main(String[] args) {
Branch root = new Branch("中西药");
Branch c1 = new Branch("中药");
Branch c2 = new Branch("西药");
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.print("");
}
}
最终结果
+中西药
+中药
-人参
-田七
+西药
-阿莫西林
-葡萄糖
安全式的缺点是不够透明，叶子节点与树枝节点来自不同的接口；而透明式的处理方式是叶子和树枝都实现相同的接口，这接口也就是根接口，根接口需要有管理的枝枝叶叶的方法，此时客户端同等对待枝枝叶叶。但也就不安全了，叶子的功能可能没有树枝那么强大，但也要有相应的能力。
透明式
照例上类图
根为接口或者抽象类，满足叶子节点不需要过多的实现对应接口。把上面的例子进行改写.
首先还是根，这次用抽象类
public abstract class Root2 {
public abstract void printStruct(String preStr);
public void addChild(Root2 child){
throw new UnsupportedOperationException("对象不支持此功能");
}
public void removeChild(int index){
throw new UnsupportedOperationException("对象不支持此功能");
}
public List<Root2> getChild(){
throw new UnsupportedOperationException("对象不支持此功能");
}
}
接着把叶子实现出来
public class Leaf2 extends Root2 {
private String name;
public Leaf2(String name){
this.name = name;
}
@Override
public void printStruct(String preStr) {
System.out.println(preStr + "-" + name);
}
}
树枝的实现如下
public class Branch2 extends Root2 {
private List<Root2> childComponents = new ArrayList<Root2>();
private String name;
public Branch2(String name){
this.name = name;
}
public void addChild(Root2 child){
childComponents.add(child);
}
public void removeChild(int index){
childComponents.remove(index);
}
public List<Root2> getChild(){
return childComponents;
}
@Override
public void printStruct(String preStr) {
System.out.println(preStr + "+" + this.name);
if(this.childComponents != null){
//向后缩进两个空格
preStr += " ";
for(Root2 c : childComponents){
c.printStruct(preStr);
}
}
}
}
最后客户端调用：
public class Client2 {
public static void main(String[] args) {
Root2 root = new Branch2("中西药");
Root2 c1 = new Branch2("中药");
Root2 c2 = new Branch2("西药");
Root2 leaf1 = new Leaf2("人参");
Root2 leaf2 = new Leaf2("田七");
Root2 leaf3 = new Leaf2("阿莫西林");
Root2 leaf4 = new Leaf2("葡萄糖");
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
root.print("");
}
}
此时不在区分是叶子还是树枝，全是根Root2来。
合成模式更看重透明性，虽然安全方面会有问题，尤其是类型转换的时候，但一般在开发过程中是可以预料的，同时叶子节点很多管理方法是平庸的，叶子毕竟功能稍弱；而透明的特点使得模式的威力更强，尤其对客户端调用而言，不再管具体的叶子还是树枝，把他看成一个整体来处理，显然比逐个逐个的零件来处理要方便的多，虽然有点小瑕疵，但还是能够接受，毕竟方便更多。
