组合模式
定义
将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
UML图
模板代码
Component
/**
* 组合对象
* Created by callmeDevil on 2019/8/11.
*/
public abstract class Component {
protected String name;
public Component(String name){
this.name = name;
}
// 通常都用add 和remove 方法来提供增加或移除树叶或树枝的功能
public abstract void add(Component c);
public abstract void remove(Component c);
public abstract void dispaly(int depth);
}Composite
/**
* 枝节点行为，用来存储子部件
* Created by callmeDevil on 2019/8/11.
*/
public class Composite extends Component{
// 一个子对象集合用来存储其下属枝节点和叶节点
private List 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 dispaly(int depth) {
StringBuilder sb = new StringBuilder(depth);
for (int i = 0; i < depth; i++) {
sb.append("-");
}
// 显示枝节点名称，并对其下级进行遍历
System.out.println(String.format("%s %s", sb.toString(), name));
for (Component child : children) {
child.dispaly(depth + 3);
}
}
} Leaf
/**
* 叶节点对象
* Created by callmeDevil on 2019/8/11.
*/
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 dispaly(int depth) {
StringBuilder sb = new StringBuilder(depth);
for (int i = 0; i < depth; i++) {
sb.append("-");
}
// 显示名称和级别
System.out.println(String.format("%s %s", sb.toString(), name));
}
}测试
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 ，分枝上也有两叶LeafXA 和LeafXB
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);
// 根部又长出两叶LeafC 和LeafD，可惜LeafD没长牢，被风吹走了
root.add(new Leaf("Leaf C"));
Leaf leafD = new Leaf("Leaf D");
root.add(leafD);
root.remove(leafD);
// 显示大树
root.dispaly(1);
}
}测试结果
- root
---- Leaf A
---- Leaf B
---- Composite X
------- Leaf XA
------- Leaf XB
------- Composite XY
---------- Leaf XYA
---------- Leaf XYB
---- Leaf C透明方式与安全方式
树可能有无数的分枝，反复使用 Composite 就可以实现树状结构，但树叶不可以再长分枝，为什么此处 Leaf 当中也有实现 add 和 remove？
这种叫做透明方式，也就是说在 Component 中声明所有用来管理子对象的方法，其中包括 add, remove 等。这样实现 Component 接口的所有子类都具备了 add 和 remove。这样做的好处是叶节点和枝节点对于外界没有区别，它们具备完全一致的行为接口，但问题也明显，因为本身不具体 add 和 remove 功能，所以实现是没有意义的。
当然也可以不去实现，这种叫做安全方式，也就是在 Component 接口中不去声明 add 和 remove 方法，那么子类的 Leaf 也就不需要去实现，而是在 Composite 声明所有用来管理子类对象的方法，不过由于不够透明，所以树叶和树枝将不具有相同的接口，客户端的调用需要做相应的判断，带来了不便。
何时使用？
当需求中是体现部分与整体层次的结构时，以及希望用户可以忽略组合对象与单个对象的不同，统一的使用组合结构中的所有对象时，就应该考虑用组合模式了。
举个栗子
问题描述
总公司与分公司关系，总公司的所有管理功能同样能使用在分公司。
代码实现
Company
/**
* 公司抽象类
* Created by callmeDevil on 2019/8/11.
*/
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 dispaly(int depth);
public abstract void lineOfDuty(); // 履行职责，不同部门需要履行不同的职责
// 用于输出层次结构，非必须，与模式无关
public String getDepth(int depth){
StringBuilder sb = new StringBuilder(depth);
for (int i = 0; i < depth; i++) {
sb.append("-");
}
return sb.toString();
}
}ConcreteCompany
/**
* 具体公司（树枝节点）
* Created by callmeDevil on 2019/8/11.
*/
public class ConcreteCompany extends Company {
private List 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 dispaly(int depth) {
System.out.println(String.format("%s %s", getDepth(depth), name));
for (Company child : children) {
child.dispaly(depth + 3);
}
}
@Override
public void lineOfDuty() {
for (Company child : children) {
child.lineOfDuty();
}
}
} HRDepartment
/**
* 人力资源部（树叶节点）
* Created by callmeDevil on 2019/8/11.
*/
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 dispaly(int depth) {
System.out.println(String.format("%s %s", getDepth(depth), name));
}
@Override
public void lineOfDuty() {
System.out.println(String.format("%s 员工招聘培训管理", name));
}
}FinanceDepartment
/**
* 财务部（树叶节点）
* Created by callmeDevil on 2019/8/11.
*/
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 dispaly(int depth) {
System.out.println(String.format("%s %s", getDepth(depth), name));
}
@Override
public void lineOfDuty() {
System.out.println(String.format("%s 公司财务收支管理", name));
}
}测试
public class Test {
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("\n 结构图：");
root.dispaly(1);
System.out.println("\n 职责：");
root.lineOfDuty();
}
}测试结果
结构图：
- 北京总公司
---- 总公司人力资源部
---- 总公司财务部
---- 上海分公司
------- 上海分公司人力资源部
------- 上海分公司财务部
------- 南京办事处
---------- 南京办事处人力资源部
---------- 南京办事处财务部
------- 杭州办事处
---------- 杭州办事处人力资源部
---------- 杭州办事处财务部
职责：
总公司人力资源部 员工招聘培训管理
总公司财务部 公司财务收支管理
上海分公司人力资源部 员工招聘培训管理
上海分公司财务部 公司财务收支管理
南京办事处人力资源部 员工招聘培训管理
南京办事处财务部 公司财务收支管理
杭州办事处人力资源部 员工招聘培训管理
杭州办事处财务部 公司财务收支管理总结
- 组合模式定义了包含基本对象、组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断的递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。
- 用户是不用关心到底是处理一个叶节点对象还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句了。
- 组合模式让客户可以一致的使用组合结构和单个对象。