设计模式学习笔记——组合模式

组合模式

组合模式，将对象组合合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

代码实现

接口声明Component

/**
* 接口声明
* @author xukai 2016年3月26日 下午4:58:37
*
*/
public abstract class Component {

protected String name;

public Component(String name) {
this.name = name;
}

public abstract void add(Component component);

public abstract void remove(Component component);

public abstract void display(int depth);

}

枝节点Composite

/**
* 枝节点
*
* @author xukai 2016年3月26日 下午5:04:52
*
*/
public class Composite extends Component {

private List<Component> children = new ArrayList<Component>();

public Composite(String name) {
super(name);
}

@Override
public void add(Component component) {
children.add(component);
}

@Override
public void remove(Component component) {
children.remove(component);
}

@Override
public void display(int depth) {
System.out.println("名称：" + name + ",深度：" + depth);
for (Component component : children) {
component.display(depth + 2);
}
}

}

叶子节点Leaf

/**
* 叶节点：无子节点
* @author xukai 2016年3月26日 下午5:01:45
*
*/
public class Leaf extends Component {

public Leaf(String name) {
super(name);
}

@Override
public void add(Component component) {
System.out.println("添加一个叶子节点");
}

@Override
public void remove(Component component) {
System.out.println("去除一个叶子节点");
}

@Override
public void display(int depth) {
System.out.println("名称：" + name + ",深度：" + depth);
}

}

客户端测试：

public class Client {

public static void main(String[] args) {
// 根节点
Composite root = new Composite("root");

root.add(new Leaf("叶子节点1"));
root.add(new Leaf("叶子节点2"));

Composite comp_A = new Composite("子节点A");
comp_A.add(new Leaf("A子叶子节点1"));
comp_A.add(new Leaf("A子叶子节点2"));

// 根节点添加A子节点
root.add(comp_A);

Composite comp_A_B = new Composite("子节点A_B");
comp_A_B.add(new Leaf("A_B子叶子节点1"));
comp_A_B.add(new Leaf("A_B子叶子节点2"));

comp_A.add(comp_A_B);

// 根节点右生出子节点
Leaf leaf = new Leaf("叶子节点3");
root.add(leaf);
root.display(1);
System.out.println("====================");
// 缺营养，挂了
root.remove(leaf);
root.display(1);
}

}

控制台输出：

名称：root,深度：1
名称：叶子节点1,深度：3
名称：叶子节点2,深度：3
名称：子节点A,深度：3
名称：A子叶子节点1,深度：5
名称：A子叶子节点2,深度：5
名称：子节点A_B,深度：5
名称：A_B子叶子节点1,深度：7
名称：A_B子叶子节点2,深度：7
名称：叶子节点3,深度：3
====================
名称：root,深度：1
名称：叶子节点1,深度：3
名称：叶子节点2,深度：3
名称：子节点A,深度：3
名称：A子叶子节点1,深度：5
名称：A子叶子节点2,深度：5
名称：子节点A_B,深度：5
名称：A_B子叶子节点1,深度：7
名称：A_B子叶子节点2,深度：7

测试的结构图：



这里需要注意一下，给Leaf叶子节点也添加了Add和remove方法，这种方式叫做透明方式，即在Component中声明所有用来管理子对象的方法，Component接口的所有子类都具有了Add和Remove。好处是叶节点和枝节点对于外界没有区别，具备完全一致的行为接口。（虽然实现它是没有意义的）

demo

问题：公司管理系统实现。

代码实现

公司的抽象接口Company

/**
* 公司抽象接口
*
* @author xukai 2016年3月26日 下午9:01:47
*
*/
public abstract class Company {

protected String name;

public Company(String name) {
this.name = name;
}

public abstract void add(Company company);

public abstract void remove(Company company);

public abstract void display(int depth);

public abstract void lineOfDuty();

}

具体公司类ConcreteCompany

/**
* 具体公司
* @author xukai 2016年3月26日 下午9:03:41
*
*/
public class ConcreteCompany extends Company {

private List<Company> children = new ArrayList<>();

public ConcreteCompany(String name) {
super(name);
}

@Override
public void add(Company company) {
children.add(company);
}

@Override
public void remove(Company company) {
children.remove(company);
}

@Override
public void display(int depth) {
System.out.println("公司名称:" + name + ",深度" + depth);
for(Company company : children){
company.display(depth+2);
}
}

@Override
public void lineOfDuty() {
for(Company company : children){
company.lineOfDuty();
}
}

}

具体部门类，人力资源部HRDepartment

/**
* 人力资源部
*
* @author xukai 2016年3月26日 下午9:17:01
*
*/
public class HRDepartment extends Company {

public HRDepartment(String name) {
super(name);
}

@Override
public void add(Company company) {

}

@Override
public void remove(Company company) {

}

@Override
public void display(int depth) {
System.out.println("部门名称:" + name + ",深度" + depth);
}

@Override
public void lineOfDuty() {
System.out.println(name + "工作：员工招聘培训管理");
}

}

财务部，FinanceDepartment

/**
* 财务部
*
* @author xukai 2016年3月26日 下午9:08:07
*
*/
public class FinanceDepartment extends Company {

public FinanceDepartment(String name) {
super(name);
}

@Override
public void add(Company company) {

}

@Override
public void remove(Company company) {

}

@Override
public void display(int depth) {
System.out.println("部门名称:" + name + ",深度" + depth);
}

@Override
public void lineOfDuty() {
System.out.println(name + "的工作：公司财务管理");
}

}

客户端：

public class Client {

public static void main(String[] args) {

ConcreteCompany company = new ConcreteCompany("总公司");
company.add(new HRDepartment("总公司人力资源部"));
company.add(new FinanceDepartment("总公司财务部"));

ConcreteCompany childrenCompany1 = new ConcreteCompany("分公司1");
childrenCompany1.add(new HRDepartment("分公司1_人力资源部"));
childrenCompany1.add(new FinanceDepartment("分公司1_财务部"));

// 总公司添加分公司1
company.add(childrenCompany1);

ConcreteCompany childrenCompany2 = new ConcreteCompany("分公司2");
childrenCompany2.add(new HRDepartment("分公司2_人力资源部"));
childrenCompany2.add(new FinanceDepartment("分公司2_财务部"));

// 总公司添加分公司2
company.add(childrenCompany2);

ConcreteCompany childrenCompany3 = new ConcreteCompany("分公司3");
childrenCompany3.add(new HRDepartment("分公司3_人力资源部"));
childrenCompany3.add(new FinanceDepartment("分公司3_财务部"));

// 总公司添加分公司3
company.add(childrenCompany3);
// 查看公司结构
company.display(1);
// 公司部门职责
company.lineOfDuty();

}

}

客户端输出：

</pre><pre name="code" class="java">公司名称:总公司,深度1
部门名称:总公司人力资源部,深度3
部门名称:总公司财务部,深度3
公司名称:分公司1,深度3
部门名称:分公司1_人力资源部,深度5
部门名称:分公司1_财务部,深度5
公司名称:分公司2,深度3
部门名称:分公司2_人力资源部,深度5
部门名称:分公司2_财务部,深度5
公司名称:分公司3,深度3
部门名称:分公司3_人力资源部,深度5
部门名称:分公司3_财务部,深度5
总公司人力资源部工作：员工招聘培训管理
总公司财务部的工作：公司财务管理
分公司1_人力资源部工作：员工招聘培训管理
分公司1_财务部的工作：公司财务管理
分公司2_人力资源部工作：员工招聘培训管理
分公司2_财务部的工作：公司财务管理
分公司3_人力资源部工作：员工招聘培训管理
分公司3_财务部的工作：公司财务管理

可以看出，总公司下有三个分公司，分公司和总公司下的部门是一个级别，分公司同样拥有和总公司类似的部门。

总结

当需求中体现部分与整体层次结构是，并且需要忽略组合对象和单个对象的不同，统一地使用组合结构中的所有对象时，可以考虑使用组合模式。

组合模式定义了基本对象和组合对象层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象可以又被组合，递归传递。使用时，任何使用基本对象的地方都可以使用组合对象。

组合模式让客户可以一致地使用组合结构和单个对象。

ps：数据结构中的树也是此思想。