组合模式的定义与特点
组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
组合模式的主要优点有：
- 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
- 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；
其主要缺点是：
- 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
- 不容易限制容器中的构件；
- 不容易用继承的方法来增加构件的新功能；
组合模式的结构与实现
组合模式的结构不是很复杂，下面对它的结构和实现进行分析。
1. 模式的结构
组合模式包含以下主要角色。
- 抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
- 树叶构件（Leaf）角色：是组合中的叶节点对象（叶子节点），它没有子节点，用于实现抽象构件角色中 声明的公共接口。
- 树枝构件（Composite）角色：是组合中的分支节点对象（非叶子节点），它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。
组合模式分为透明式的组合模式和安全式的组合模式。
(1) 透明方式：在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。
代码实现：
/**
* 组织结构，相当于Component接口
*
* @author Administrator
*/
public abstract class OrganizationComponent {
/**
* 名称
*/
private String name;
/**
* 说明
*/
private String desc;
public OrganizationComponent(String name, String desc) {
super();
this.name = name;
this.desc = desc;
}
/**
* 新增方法，默认实现 这里不写成抽象方法，是考虑叶子节点不需要实现改方法
*/
protected void add(OrganizationComponent component) {
throw new UnsupportedOperationException();
}
protected void remove(OrganizationComponent component) {
throw new UnsupportedOperationException();
}
/**
* 打印方法，描述基本信息
*/
public abstract void print();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
@Override
public String toString() {
return "OrganizationComponent [name=" + name + ", desc=" + desc + "]";
}
}
/**
* University根节点，下级为Collage，相当于Composite
*
* @author Administrator
*/
public class University extends OrganizationComponent {
/**
* list存放的是学院Collage
*/
private List<OrganizationComponent> organizationComponentList = new ArrayList<>();
public University(String name, String desc) {
super(name, desc);
}
@Override
protected void add(OrganizationComponent component) {
organizationComponentList.add(component);
}
@Override
protected void remove(OrganizationComponent component) {
organizationComponentList.remove(component);
}
@Override
public void print() {
System.out.println("================================");
System.out.println(this.toString());
// 遍历输出学院
for (OrganizationComponent organizationComponent : organizationComponentList) {
organizationComponent.print();
}
}
@Override
public String toString() {
return "University [name=" + getName() + ", desc=" + getDesc() + "]";
}
}
/**
* 上级为University，下级为Department，相当于Composite
*
* @author Administrator
*/
public class Collage extends OrganizationComponent {
/**
* 这个list存方法的是院系Department
*/
private List<OrganizationComponent> organizationComponentList = new ArrayList<>();
public Collage(String name, String desc) {
super(name, desc);
}
@Override
protected void add(OrganizationComponent component) {
organizationComponentList.add(component);
}
@Override
protected void remove(OrganizationComponent component) {
organizationComponentList.remove(component);
}
@Override
public void print() {
System.out.println("================================");
System.out.println(this.toString());
// 遍历输出学院
for (OrganizationComponent organizationComponent : organizationComponentList) {
organizationComponent.print();
}
}
@Override
public String toString() {
return "Collage [name=" + getName() + ", desc=" + getDesc() + "]";
}
}
/**
* Department，叶子节点，相当于Leaf
* 不需要实现add，remove方法
*
* @author Administrator
*/
public class Department extends OrganizationComponent {
public Department(String name, String desc) {
super(name, desc);
}
@Override
public void print() {
System.out.println(this.toString());
}
@Override
public String toString() {
return "Department [name=" + getName() + ", desc=" + getDesc() + "]";
}
}
public class Client {
public static void main(String[] args) {
// 创建点击节点，university
OrganizationComponent university = new University("北京大学", "中国顶级大学");
// 创建节点，collage
OrganizationComponent collage1 = new Collage("计算机学院", "中国顶级计算机学院");
OrganizationComponent collage2 = new Collage("古汉语学院", "中国顶级古汉语学院");
// 创建叶子节点，Department
OrganizationComponent department11 = new Department("软件工程", "中国顶级软件工程");
OrganizationComponent department12 = new Department("物联网", "中国顶级物联网专业");
collage1.add(department11);
collage1.add(department12);
university.add(collage1);
OrganizationComponent department21 = new Department("八股文", "中国顶级八股文专业");
collage2.add(department21);
university.add(collage2);
university.print();
}
}
运行结果：
(2) 安全方式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。
2. 模式的实现
假如要访问集合 c0={leaf1,{leaf2,leaf3}} 中的元素，其对应的树状图如图 3 所示。
下面给出透明式的组合模式的实现代码，与安全式的组合模式的实现代码类似，只要对其做简单修改就可以了。
组合模式的应用场景
前面分析了组合模式的结构与特点，下面分析它适用的以下应用场景。
- 在需要表示一个对象整体与部分的层次结构的场合。
- 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。
组合模式的扩展
如果对前面介绍的组合模式中的树叶节点和树枝节点进行抽象，也就是说树叶节点和树枝节点还有子节点，这时组合模式就扩展成复杂的组合模式了，如 Java AWT/Swing 中的简单组件 JTextComponent 有子类 JTextField、JTextArea，容器组件 Container 也有子类 Window、Panel。复杂的组合模式的结构图如图 5 所示。
