组合模式

组合模式（Composite Pattern）也称之为整体-部分（Part-Whole）模式。组合模式的核心是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得单个对象和组合对象的使用具有一致性，组合模式属于结构型模式。
组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，最顶层的节点称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点如下图所示：
组合模式 - 图1
组合模式有两种写法，分别是透明模式和安全模式。下面我们会分别示范这两种写法，并对其进行对比分析。

透明模式


下面我们以高考的科目为例，来看看组合模式中的透明模式该如何实现（这里我们需要新建 composite/transparency 目录，相关类创建在 composite/transparency 目录下）。

  • 首先新建一个高考科目的抽象类 GkAbstractCourse.java，里面提供了三个方法。
  1. package composite.transparency;
  3. public abstract class GkAbstractCourse {
  4.     public void addChild(GkAbstractCourse course){//添加子节点
  5.         System.out.println("不支持添加操作");
  6.     }
  8.     public String getName() throws Exception {//获取当前节点名称
  9.         throw new Exception("不支持获取名称");
  10.     }
  12.     public void info() throws Exception{//获取高考科目信息
  13.         throw new Exception("不支持查询信息操作");
  14.     }
  15. }

这个类是抽象类，但是在这里并没有将这些方法定义为抽象方法，而是默认都抛出异常。这么做的原因是假如定义为抽象方法，那么所有的子类都必须重写父类方法。但是这种通过抛异常的方式，如果子类需要用到的功能就重写覆盖父类方法即可，不需要用到的方法直接无需重写。

  • 新增一个叶子节点，普通高考科目类 LeafCource.java 来继承 GkAbstractCourse 类，这个类就是最底层，无法包含其它科目，比如语文，正因为其无法包含其它课程所以不需要重写 addChild 方法。
  1. package composite.transparency;
  3. public class LeafCource extends GkAbstractCourse {
  4.     private String name;//课程名称
  5.     private String score;//课程分数
  7.     public LeafCource(String name, String score) {
  8.         this.name = name;
  9.         this.score = score;
  10.     }
  12.     @Override
  13.     public String getName(){
  14.         return this.name;
  15.     }
  17.     @Override
  18.     public void info() {
  19.         System.out.println("课程:" + this.name + ",分数:" + score);
  20.     }
  21. }
  • 接下来新建一个树枝类 BranchCource.java，当前类可以包含其它科目的类，比如理综可以包括物理、化学和生物，这个类将父类的 3 个方法全部进行了重写。 ```java package composite.transparency;

import java.util.ArrayList; import java.util.List;

public class BranchCource extends GkAbstractCourse{ private List courseList = new ArrayList<>(); private String name;//科目名称 private int level;//层级

  1. public BranchCource(String name, int level) {
  2.     this.name = name;
  3.     this.level = level;
  4. }
  6. @Override
  7. public void addChild(GkAbstractCourse course) {//添加子课程
  8.     courseList.add(course);
  9. }
  11. @Override
  12. public String getName(){//获取课程名称
  13.     return this.name;
  14. }
  16. @Override
  17. public void info() throws Exception {//打印课程信息
  18.    System.out.println("课程:" + this.name);
  19.    for (GkAbstractCourse course : courseList){
  20.        for (int i=0;i<level;i++){//根据层级关系打印空格，这样打印结果可以明显看出层级关系
  21.            System.out.print("  ");
  22.        }
  23.        System.out.print(">");
  24.        course.info();
  25.    }
  26. }

}

  2. - 最后我们新建一个测试类 TestTransparency.java 来测试一下。
  4. ```java
  5. package composite.transparency;
  7. public class TestTransparency {
  8.     public static void main(String[] args) throws Exception {
  9.         GkAbstractCourse ywCourse = new LeafCource("语文","150");
  10.         GkAbstractCourse sxCourse = new LeafCource("数学","150");
  11.         GkAbstractCourse yyCourse = new LeafCource("英语","150");
  13.         GkAbstractCourse wlCourse = new LeafCource("物理","110");
  14.         GkAbstractCourse hxCourse = new LeafCource("化学","100");
  15.         GkAbstractCourse swCourse = new LeafCource("生物","90");
  17.         GkAbstractCourse lzCourse = new BranchCource("理综",2);
  18.         lzCourse.addChild(wlCourse);
  19.         lzCourse.addChild(hxCourse);
  20.         lzCourse.addChild(swCourse);
  22.         GkAbstractCourse gkCourse = new BranchCource("理科高考",1);
  23.         gkCourse.addChild(ywCourse);
  24.         gkCourse.addChild(sxCourse);
  25.         gkCourse.addChild(yyCourse);
  27.         gkCourse.addChild(lzCourse);
  28.         gkCourse.info();
  29.         swCourse.addChild(ywCourse);//这里会报错，因为生物已经是叶子节点，无法继续添加子节点
  30.     }
  31. }

执行 javac composite/transparency/*.java 命令进行编译，然后再执行 java composite.transparency.TestTransparency 命令运行测试类（大家一定要自己动手运行哦，只有自己实际去运行了才会更能体会其中的思想）。
组合模式 - 图2
上面就是一个透明模式的写法，之所以称之为透明模式就是因为父类将所有方法都定义好了，对各个子类完全透明。这样做的好处是客户端无需分辨当前对象是属于树枝节点还是叶子节点，因为它们具备了完全一致的接口，不过缺点就是叶子节点得到了一些不属于它的方法，比如上面的 addChild 方法，这个很明显违背了接口隔离性原则。
而组合模式只是规定了系统各个层次的最基础的一致性行为，而把组合（树节点）本身的方法（如树枝节点管理子类的 addChild 等方法）放到自身当中。接下来我们再看看安全模式应该如何实现。

安全模式示例

这里我们新建一个 composite/safe 目录，相关类创建在 composite/safe 目录下。

  • 首先还是新建一个顶层的抽象课程类 GkAbstractCourse.java，不过这次只定义了一个通用的查询课程信息的方法，而且是抽象方法，同时又多具备了课程名字和课程分数两个属性。
  1. package composite.safe;
  3. public abstract class GkAbstractCourse {
  4.     protected String name;//课程名称
  5.     protected String score;//课程分数
  7.     public GkAbstractCourse(String name, String score) {
  8.         this.name = name;
  9.         this.score = score;
  10.     }
  12.     public abstract void info();//获取课程信息
  13. }
  • 新增一个叶子节点，普通高考科目类 LeafCource.java 来继承 GkAbstractCourse 类，这个类就是最底层，无法包含其它科目，比如语文，所以它没什么其它特殊的自定义方法。 ```java package composite.safe;

public class LeafCource extends GkAbstractCourse { public LeafCource(String name, String score) { super(name,score); }

  1. @Override
  2. public void info() {//获取课程信息
  3.     System.out.println("课程:" + this.name + ",分数:" + this.score);
  4. }

}

  2. - 接下来新建一个树枝类 BranchCource.java，当前类可以包含其它科目的类，比如理综可以包括物理、化学和生物，所以这个类额外自定义了一个层级属性和一个添加子课程 addChild 方法。
  4. ```java
  5. package composite.safe;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. public class BranchCource extends GkAbstractCourse{
  11.     private List<GkAbstractCourse> courseList = new ArrayList<>();//子课程
  12.     private int level;//层级
  14.     public BranchCource(String name, String score, int level) {
  15.         super(name,score);
  16.         this.level = level;
  17.     }
  19.     public void addChild(GkAbstractCourse course) {//添加子课程
  20.         courseList.add(course);
  21.     }
  23.     @Override
  24.     public void info() {//打印课程信息
  25.        System.out.println("课程:" + this.name + ",分数：" + this.score);
  26.        for (GkAbstractCourse course : courseList){
  27.            for (int i=0;i<level;i++){//根据层级关系打印空格，这样打印结果可以明显看出层级关系
  28.                System.out.print("  ");
  29.            }
  30.            System.out.print(">");
  31.            course.info();
  32.        }
  33.     }
  34. }
  • 最后我们新建一个测试类 TestSafe.java 来测试一下。
  1. package composite.safe;
  3. public class TestSafe {
  4.     public static void main(String[] args) throws Exception {
  5.         LeafCource ywCourse = new LeafCource("语文","150");
  6.         LeafCource sxCourse = new LeafCource("数学","150");
  7.         LeafCource yyCourse = new LeafCource("英语","150");
  9.         LeafCource wlCourse = new LeafCource("物理","110");
  10.         LeafCource hxCourse = new LeafCource("化学","100");
  11.         LeafCource swCourse = new LeafCource("生物","90");
  13.         BranchCource lzCourse = new BranchCource("理综","300",2);
  14.         lzCourse.addChild(wlCourse);
  15.         lzCourse.addChild(hxCourse);
  16.         lzCourse.addChild(swCourse);
  18.         BranchCource gkCourse = new BranchCource("理科高考","750",1);
  19.         gkCourse.addChild(ywCourse);
  20.         gkCourse.addChild(sxCourse);
  21.         gkCourse.addChild(yyCourse);
  23.         gkCourse.addChild(lzCourse);
  24.         gkCourse.info();
  25.     }
  26. }

执行 javac composite/safe/*.java 命令进行编译，然后再执行 java composite.safe.TestSafe 命令运行测试类（大家一定要自己动手运行哦，只有自己实际去运行了才会更能体会其中的思想）。
组合模式 - 图3
这里和透明方式不一样，叶子节点不具备 addChild 功能，所以无法调用，而上面的示例中时可以被调用，但是调用之后显示不支持，这就是这两种写法最大的区别。

组合模式适用场景

组合模式一般应用在有层级关系的场景，最经典的就是树形菜单、文件和文件夹的管理等。

组合模式优点

组合模式清楚的定义了分层次的复杂对象，让客户端可以忽略层次的差异，方便对整个层次进行动态控制。

组合模式缺点

组合模式的叶子和树枝的声明是实现类而不是接口，违反了依赖倒置原则，而且组合模式会使设计更加抽象不好理解。