层级结构——组合模式

组合模式

​ Composite Pattern：组合模式，也可以称为部分整体模式。是GoF23种设计模式之中属于结构型模式的一种。

​ 组合模式是依据树形结构来组合对象体现出部分-整体的层次结构，组合模式hi将一组相似的对象当成一个单一的对象，使得对单个对象和组合对象的使用具有一致性。

​

结构

​ 结合类图简单的分析一下，组合模式共有三个对象：

1. 组合模型对象（Component）：为组合中的对象声明接口用于访问和管理Component的子部件。
2. 叶子节点对象（Leaf）：叶子节点是没有子节点的对象。
3. 树枝节点对象（Composite）：树枝节点用来存储子部件，并且实现与子部件相关的操作。

举例

• 组合模型的一个十分场景的用处就是电脑上面的文件系统。大多文件的存储都是树形的结构类似于这样:

  C:
  --AppData
  ----Flash Player
  ----Roaming
  --Program Files
  ----IIS
  ------Microsoft Web Deploy
  ----Intel
  ------HAXM
  ------Media SDK
  ----Microsoft Office
  --Program Files(x86)
  ----ASUS
  ----Cisco
  ----Google
  --Windows
  ----ASUS
  ------DPTF
  ------PDX
  --------Channel
  ----Boot
  

  这就是一种典型的树形的层次结构，也是组合模式的体现标准。

• 另外的例子比如数学上的计算表达式，1+1是最简单的不用进行分割，但是我们知道先乘除后加减，有括号先算括号里面的，就像1 * (3 - 5 * (3 - 4 / (3 * 4)))

  根据括号的优先级高，这个计算表达式也是分成了层级的，从最里面的括号开始计算逐层向外面计算得到最后的结果。

注意

1. 组合模式可以优化处理递归或者分级数据结构。

2. 组合模式所有的部件有着统一的操作方式，所以高层模块调用简单，节点也是自由增加删除的。

3. 但是组合模式违反了依赖倒置原则，因为叶子对象和树枝对象都是组合模型对象的实现类而不是接口。

4. 在组合模型中声明所有用来管理子对象的方法，但是对于没有子节点的叶子对象来说，添加和删除的实现是没有必要的，但是这样可以保证所有的子部件都具有完全一直的行为，这是透明方式的实现。如果不想实现，那么就需要将增加和删除子部件的行为让具体的实现类来实现，这样导致叶子节点和树枝节点的行为不一致会让用户调用有一定的麻烦，这是安全方式的实现。

   显然，透明方式比安全方式更加简单，不必做多余的判断。

5. 简单的说，组合模式就是让客户可以一致性的使用组合结构和单个对象。

一个小DEMO

1. 场景

   组合模式的分层场景，除了在文件系统中使用的多之外，对于各种组织机构来说都是采用的分层的模式。比如公司，比如学校，比如国家等等，都是一层层的层级单位。

   这个小DEMO就以学校的分层为例子吧。

2. 组合模型

   /**
    * 组合模式——组合模型对象  可以是抽象类也可以是接口
    * 这里就是场景中的抽象对象  学校
    * @author wq
    */
   public abstract class School {
   	protected String name;
   	
   	public School(String name) {
   		this.name = name;
   	}
   	
   	// 增加子部件的方法
   	public abstract void add(School school);
   	// 删除子部件的方法
   	public abstract void remoce(School school);
   	// 显示自己的方法
   	public abstract void display(int depth);
   	// 定义自己的行为的方法
   	public abstract void doSomething();
   }
   

3. 具体的树枝节点对象

   /**
    * 组合模式——树枝节点对象
    * 这是具体的学校对象
    * @author wq
    */
   import java.util.ArrayList;
   import java.util.List;
   
   public class ConcreteSchool extends School{
   	private List<School> schools = new ArrayList<School>();
   	
   	public ConcreteSchool(String name) {
   		super(name);
   	}
   
   	@Override
   	public void add(School school) {
   		schools.add(school);
   	}
   
   	@Override
   	public void remoce(School school) {
   		school.remoce(school);
   	}
   
   	@Override
   	public void display(int depth) {
   		for (int i = 0; i < depth; i++) {
   			System.out.print("-");
   		}
   		System.out.println(name);
   		for (School school : schools) {
   			school.display(depth + 2);
   		}
   	}
   
   	@Override
   	public void doSomething() {
   		for(School school : schools) {
   			school.doSomething();
   		}
   	}	
   }
   

4. 叶子节点对象

   /**
    * 组合模式——叶子节点对象
    * 叶子节点中的添加和删除子部件的方式实现是没有意义的
    * 教师  负责的传道授业解惑
    * @author wq
    */
   public class Teacher extends School{
   	public Teacher(String name) {
   		super(name);
   	}
   
   	@Override
   	public void add(School school) {	}
   
   	@Override
   	public void remoce(School school) {	}
   
   	@Override
   	public void display(int depth) {
   		for (int i = 0; i < depth; i++) {
   			System.out.print("-");
   		}
   		System.out.println(name);
   	}
   
   	@Override
   	public void doSomething() {
   		System.out.println(name + "  传道授业解惑");
   	}
   }
   //---------------------------------------------------------------------
   /**
    * 组合模式——叶子节点对象
    * 叶子节点中的添加和删除子部件的方式实现是没有意义的
    * 学生  负责接收教育
    * @author wq
    */
   public class Student extends School{
   	public Student(String name) {
   		super(name);
   	}
   
   	@Override
   	public void add(School school) {	}
   
   	@Override
   	public void remoce(School school) {	}
   
   	@Override
   	public void display(int depth) {
   		for (int i = 0; i < depth; i++) {
   			System.out.print("-");
   		}
   		System.out.println(name);
   	}
   
   	@Override
   	public void doSomething() {
   		System.out.println(name + "  接受教育");
   	}
   }
   

5. 测试类

   /**
    * 组合模式——测试类
    * @author wq
    */
   public class Main {
   	public static void main(String[] args) {
   		ConcreteSchool root = new ConcreteSchool("XXX教育集团");
   		
   		ConcreteSchool highSchool = new ConcreteSchool("高中部");
   		highSchool.add(new Teacher("高中教师"));
   		highSchool.add(new Student("高中学子"));
   		root.add(highSchool);
   		
   		ConcreteSchool juniorMiddleSchool = new ConcreteSchool("初中部");
   		juniorMiddleSchool.add(new Teacher("初中教师"));
   		juniorMiddleSchool.add(new Student("初中学子"));
   		root.add(juniorMiddleSchool);
   		
   		ConcreteSchool primarySchool = new ConcreteSchool("小学部");
   		primarySchool.add(new Teacher("小学教师"));
   		primarySchool.add(new Student("小学学子"));
   		root.add(primarySchool);
   		
   		System.out.println("学校的层级结构：");
   		root.display(0);
   		
   		System.out.println("各个子部件的行为：");
   		root.doSomething();
   	}
   }
   

6. 测试走一波

   学校的层级结构：
   XXX教育集团
   --高中部
   ----高中教师
   ----高中学子
   --初中部
   ----初中教师
   ----初中学子
   --小学部
   ----小学教师
   ----小学学子
   各个子部件的行为：
   高中教师  传道授业解惑
   高中学子  接受教育
   初中教师  传道授业解惑
   初中学子  接受教育
   小学教师  传道授业解惑
   小学学子  接受教育
   

   完成！！！