组合模式（Composite）将对象组合成树形结构以表示部分-整体的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
Component为组合中对象声明接口，在适当情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component的子部件。
public abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
public abstract void add(Component c);
public abstract void remove(Component c);
public abstract void display(int depth);
}
Leaf在组合中表示叶节点对象，叶节点没有子节点，所以add和remove方法实现它没有意义，但是这样做可以消除叶节点和枝节点对象在抽象层次的区别，它们具备完全一致的接口。
public class Leaf extends Component {
public Leaf(String name) {
super(name);
}
@Override
public void add(Component c) {
System.out.println("Cannot add to a leaf");
}
@Override
public void remove(Component c) {
System.out.println("Cannot remove from a leaf");
}
@Override
//叶节点的具体方法，在此处是显示其名称和级别
public void display(int depth) {
char[] line = new char[depth];
for(int i = 0; i < depth; i++) {
line[i] = '-';
}
System.out.println(new String(line) + name);
}
}
Composite定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加add和删除remove
public class Composite extends Component {
//用一个对象集合来存储其下属的枝节点和叶节点
private List<Component> children = new ArrayList<>();
public Composite(String name) {
super(name);
}
@Override
public void add(Component c) {
children.add(c);
}
@Override
public void remove(Component c) {
children.remove(c);
}
@Override
//显示其枝节点名称，并对其下级进行遍历
public void display(int depth) {
char[] line = new char[depth];
for(int i = 0; i < depth; i++) {
line[i] = '-';
}
System.out.println(new String(line) + name);
for(Component component : children) {
component.display(depth + 2);
}
}
}
客户端代码，能通过Component接口操作组合部件的对象
public class Test {
public static void main(String[] args) {
//生成树根root，根上长处两叶LeafA和LeafB
Composite root = new Composite("root");
root.add(new Leaf("Leaf A"));
root.add(new Leaf("Leaf B"));
//根上长处分枝Composite X，分枝上也有两叶Leaf XA和Leaf XB
Composite comp = new Composite("Composite X");
comp.add(new Leaf("Leaf XA"));
comp.add(new Leaf("Leaf XB"));
root.add(comp);
//在Composite X上再长出分枝Composite XY，分枝上有两叶Leaf XYA和Leaf XYB
Composite comp2 = new Composite("Composite XY");
comp2.add(new Leaf("Leaf XYA"));
comp2.add(new Leaf("Leaf XYB"));
comp.add(comp2);
//根部又长出两叶Leaf C和Leaf D但Leaf D被吹走了
root.add(new Leaf("Leaf C"));
Leaf leaf = new Leaf("Leaf D");
root.add(leaf);
root.remove(leaf);
root.display(1);
/*-root
---Leaf A
---Leaf B
---Composite X
-----Leaf XA
-----Leaf XB
-----Composite XY
-------Leaf XYA
-------Leaf XYB
---Leaf C*/
}
}
在Component中声明所有用来管理子对象的方法，其中包括add、remove等，这样实现Component接口的所有子类都具备了add和remove，这样做的好处就是叶节点和枝节点对于外界没有区别，它们具备完全一致的行为接口。但问题是因为Leaf本身不具备add和remove方法的功能，所以实现它是没有意义的。这叫做透明方式。
如果在Component接口中不去声明add和remove方法，那么子类的Leaf也就不需要去实现它，而是在Composite声明所有用来管理子类对象的方法，这样就不会出现刚才提到的问题，不过由于不够透明，所以树叶和树枝类将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。这叫做安全方式。
需求中是体现部分与整体层次的结构式，并且希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，应该考虑使用组合模式。
下面的例子是一个公司OA系统的抽象，总部、分部、办事处是树状结构，总公司的人力资源部、财务部等办公管理功能在所有的分公司和办事处都需要有。
公司抽象类，除了增加、移除、显示外，还增加了履行职责方法，不同部门需要履行不同的职责。
public abstract class Company {
protected String name;
public Company(String name) {
this.name = name;
}
public abstract void add(Company c);
public abstract void remove(Company c);
public abstract void display(int depth);
public abstract void lineOfDuty();
}
具体公司类，实现接口树枝节点
public class ConcreteCompany extends Company {
private List<Company> children = new ArrayList<>();
public ConcreteCompany(String name) {
super(name);
}
@Override
public void add(Company c) {
children.add(c);
}
@Override
public void remove(Company c) {
children.remove(c);
}
@Override
public void display(int depth) {
char[] line = new char[depth];
for(int i = 0; i < depth; i++) {
line[i] = '-';
}
System.out.println(new String(line) + name);
for(Company component : children) {
component.display(depth + 2);
}
}
@Override
public void lineOfDuty() {
for(Company component : children) {
component.lineOfDuty();
}
}
}
人力资源部与财务部，实现树叶结点
public class HRDepartment extends Company {
public HRDepartment(String name) {
super(name);
}
@Override
public void add(Company c) {
}
@Override
public void remove(Company c) {
}
@Override
public void display(int depth) {
char[] line = new char[depth];
for(int i = 0; i < depth; i++) {
line[i] = '-';
}
System.out.println(new String(line) + name);
}
@Override
public void lineOfDuty() {
System.out.println(name + "员工招聘培训管理");
}
}
public class FinanceDepartment extends Company {
public FinanceDepartment(String name) {
super(name);
}
@Override
public void add(Company c) {
}
@Override
public void remove(Company c) {
}
@Override
public void display(int depth) {
char[] line = new char[depth];
for(int i = 0; i < depth; i++) {
line[i] = '-';
}
System.out.println(new String(line) + name);
}
@Override
public void lineOfDuty() {
System.out.println(name + "公司财务收支管理");
}
}
客户端代码
public class CompanyTest {
public static void main(String[] args) {
ConcreteCompany root = new ConcreteCompany("北京总公司");
root.add(new HRDepartment("总公司人力资源部"));
root.add(new FinanceDepartment("总公司财务部"));
ConcreteCompany comp = new ConcreteCompany("上海华东分公司");
comp.add(new HRDepartment("华东分公司人力资源部"));
comp.add(new FinanceDepartment("华东分公司财务部"));
root.add(comp);
ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
comp1.add(new HRDepartment("南京办事处人力资源部"));
comp1.add(new FinanceDepartment("南京办事处财务部"));
comp.add(comp1);
ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
comp2.add(new HRDepartment("杭州办事处人力资源部"));
comp2.add(new FinanceDepartment("杭州办事处财务部"));
comp.add(comp2);
System.out.println("结构图：");
root.display(1);
System.out.println("\n职责：");
root.lineOfDuty();
}
}
输出结果
结构图：
-北京总公司
---总公司人力资源部
---总公司财务部
---上海华东分公司
-----华东分公司人力资源部
-----华东分公司财务部
-----南京办事处
-------南京办事处人力资源部
-------南京办事处财务部
-----杭州办事处
-------杭州办事处人力资源部
-------杭州办事处财务部
职责：
总公司人力资源部员工招聘培训管理
总公司财务部公司财务收支管理
华东分公司人力资源部员工招聘培训管理
华东分公司财务部公司财务收支管理
南京办事处人力资源部员工招聘培训管理
南京办事处财务部公司财务收支管理
杭州办事处人力资源部员工招聘培训管理
杭州办事处财务部公司财务收支管理
组合模式定义了包含人力资源和财务部这些基本对象和分公司、办事处等组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户端代码中，任何用到基本对象的地方都可以使用组合对象。这样，用户不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而歇一歇判断语句。所以，组合模式的优点是让客户可用一致地使用组合结构和单个对象。
