设计模式-结构型-08-组合模式

1、学校院系展示需求

编写程序展示一个学校院系结构：

需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图：

传统方式解决学校院系展示（类图）

问题分析

• 1）将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的
• 2）实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。因此这种方案，不能很好实现的 管理 的操作，比如对学院、系的添加、删除、遍历等
• 3）解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作 ==> 组合模式

2、组合模式基本介绍

• 1）组合模式（Composite Pattern），又叫部分整体模式。它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系

• 2）组合模式依据树形结构来组合对象，用来表示部分以及整体层次

• 3）这种类型的设计模式属于结构型模式

• 4）组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象
  
  对原理结构图的说明一即组合模式的角色及职责

• 1）Component：这是组合中对象声明接口。在适当情况下，实现所有类共有的接口默认行为，用于访问和管理 Component子部件。Component可以是抽象类或者接口

• 2）Leaf：在组合中表示叶子结点，叶子结点没有子节点

• 3）Composite：非叶子结点，用于存储子部件，在Component接口中实现子部件的相关操作。比如增加、删除

解决的问题

组合模式解决这样的问题，当我们的要处理的对象可以生成一棵树形结构，而我们要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子

3、组合模式示例

组合模式有两种写法，分别是透明模式和安全模式。

3.1、 解决学校院系展示（透明模式1）

UML 类图

核心代码

// Component 抽象类
public abstract class OrganizationComponent {private String name;public OrganizationComponent(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void add(OrganizationComponent organizationComponent) {throw new UnsupportedOperationException();}public void remove(OrganizationComponent organizationComponent) {throw new UnsupportedOperationException();}public abstract void print();
}
// Composite 非叶子节点
public class University extends OrganizationComponent {List<OrganizationComponent> organizationComponentList = new ArrayList<>();public University(String name) {super(name);}@Overridepublic void add(OrganizationComponent organizationComponent) {organizationComponentList.add(organizationComponent);}@Overridepublic void remove(OrganizationComponent organizationComponent) {organizationComponent.remove(organizationComponent);}@Overridepublic void print() {for (OrganizationComponent organizationComponent : organizationComponentList) {organizationComponent.print();}}
}
public class College extends OrganizationComponent {List<OrganizationComponent> organizationComponentList = new ArrayList<>();public College(String name) {super(name);}@Overridepublic void add(OrganizationComponent organizationComponent) {organizationComponentList.add(organizationComponent);}@Overridepublic void remove(OrganizationComponent organizationComponent) {organizationComponent.remove(organizationComponent);}@Overridepublic void print() {System.out.println("=============" + getName() + "=============");for (OrganizationComponent organizationComponent : organizationComponentList) {organizationComponent.print();}}
}
// Leaf 叶子结点
public class Major extends OrganizationComponent {public Major(String name) {super(name);}@Overridepublic void print() {System.out.println(getName());}
}
// 客户端
public class Client {public static void main(String[] args) {//大学OrganizationComponent university = new University("清华大学");//学院OrganizationComponent computerCollege = new College("计算机学院");OrganizationComponent infoEngineerCollege = new College("信息工程学院");//专业computerCollege.add(new Major("软件工程"));computerCollege.add(new Major("网络工程"));computerCollege.add(new Major("计算机科学与技术"));infoEngineerCollege.add(new Major("通信工程"));infoEngineerCollege.add(new Major("信息工程"));university.add(computerCollege);university.add(infoEngineerCollege);university.print();}
}

打印结果

  //=============计算机学院=============//软件工程//网络工程//计算机科学与技术//=============信息工程学院=============//通信工程//信息工程

3.2、高考的科目（透明模式2）

1、首先建立一个顶层的抽象科目类,这个类中定义了三个通用操作方法，但是均默认不支持操作

package com.zwx.design.pattern.composite.transparency;/*** 顶层抽象组件*/
public abstract class GkAbstractCourse {public void addChild(GkAbstractCourse course) {System.out.println("不支持添加操作");}public String getName() throws Exception {throw new Exception("不支持获取名称");}public void info() throws Exception {throw new Exception("不支持查询信息操作");}
}

PS：这个类中的公共方法之所以不定义为抽象方法的原因是因为假如定义为抽象方法，那么所有的子类都必须重写父类方法，这样体现不出差异性。而这种通过抛异常的方式，如果子类需要用到的功能就重写覆盖父类方法即可。

2、新建一个普通科目类继承通用科目抽象类，这个类作为叶子节点，没有重写addChild方法，也就是这个类属于叶子节点，不支持添加子节点：

package com.zwx.design.pattern.composite.transparency;/*** 普通科目类(叶子节点)*/
public class CommonCource extends GkAbstractCourse {private String name;private String score;public CommonCource(String name, String score) {this.name = name;this.score = score;}@Overridepublic String getName() {return this.name;}@Overridepublic void info() {System.out.println("课程:" + this.name + ",分数:" + score);}
}

3、建立一个具有层级的节点，三个方法都重写了，支持添加子节点，这个类里面为了方便打印的时候看出层级关系，所以我定义了一个层级属性。

package com.zwx.design.pattern.composite.transparency;import java.util.ArrayList;
import java.util.List;/*** 树枝节点*/
public class LevelCource extends GkAbstractCourse {private List<GkAbstractCourse> courseList = new ArrayList<>();private String name;private int level;public LevelCource(String name, int level) {this.name = name;this.level = level;}@Overridepublic void addChild(GkAbstractCourse course) {courseList.add(course);}@Overridepublic String getName() {return this.name;}@Overridepublic void info() throws Exception {System.out.println("课程:" + this.name);for (GkAbstractCourse course : courseList) {for (int i = 0; i < level; i++) {System.out.print(" ");}System.out.print(">");course.info();}}
}

4、建立一个测试类来测试一下：

package com.zwx.design.pattern.composite.transparency;public class TestTransparency {public static void main(String[] args) throws Exception {GkAbstractCourse ywCourse = new CommonCource("语文", "150");GkAbstractCourse sxCourse = new CommonCource("数学", "150");GkAbstractCourse yyCourse = new CommonCource("英语", "150");GkAbstractCourse wlCourse = new CommonCource("物理", "110");GkAbstractCourse hxCourse = new CommonCource("化学", "100");GkAbstractCourse swCourse = new CommonCource("生物", "90");GkAbstractCourse lzCourse = new LevelCource("理综", 2);lzCourse.addChild(wlCourse);lzCourse.addChild(hxCourse);lzCourse.addChild(swCourse);GkAbstractCourse gkCourse = new LevelCource("理科高考科目", 1);gkCourse.addChild(ywCourse);gkCourse.addChild(sxCourse);gkCourse.addChild(yyCourse);gkCourse.addChild(lzCourse);gkCourse.info();}
}

输出结果：

课程:理科高考科目  
> 课程:语文,分数:150  
> 课程:数学,分数:150  
> 课程:英语,分数:150  
> 课程:理综  >课程:物理,分数:110  >课程:化学,分数:100  >课程:生物,分数:90

这里如果用普通科目去调用add方法就会抛出异常，假如上面调用：

swCourse.addChild(ywCourse);

会输出

不支持添加操作

因为在普通科目类里面并没有重写addChild方法。

透明组合模式的缺陷

透明模式的特点就是将组合对象所有的公共方法都定义在了抽象组件内，这样做的好处是客户端无需分辨当前对象是属于树枝节点还是叶子节点，因为它们具备了完全一致的接口，不过缺点就是叶子节点得到到了一些不属于它的方法，比如上面的addChild方法，这违背了接口隔离性原则。

3.3、高考的科目（安全组合模式）

安全组合模式只是规定了系统各个层次的最基础的一致性行为，而把组合(树节点)本身的方法(如树枝节点管理子类的addChild等方法)放到自身当中。

1、首先还是建立一个顶层的抽象根节点(这里面只定义了一个通用的抽象info方法)：

package com.zwx.design.pattern.composite.safe;package com.zwx.design.pattern.composite.safe;/*** 顶层抽象组件*/
public abstract class GkAbstractCourse {protected String name;protected String score;public GkAbstractCourse(String name, String score) {this.name = name;this.score = score;}public abstract void info();
}

2、建立一个叶子节点（这里只是重写了info方法，没有定义其他特有方法）：

package com.zwx.design.pattern.composite.safe;/*** 叶子节点*/
public class CommonCource extends GkAbstractCourse {public CommonCource(String name, String score) {super(name, score);}@Overridepublic void info() {System.out.println("课程:" + this.name + ",分数:" + this.score);}
}

3、定义一个树枝节点（这个类当中定义了一个树枝特有的方法addChild）：

package com.zwx.design.pattern.composite.safe;import java.util.ArrayList;
import java.util.List;/*** 树枝节点*/
public class LevelCource extends GkAbstractCourse {private List<GkAbstractCourse> courseList = new ArrayList<>();private int level;public LevelCource(String name, String score, int level) {super(name, score);this.level = level;}public void addChild(GkAbstractCourse course) {courseList.add(course);}@Overridepublic void info() {System.out.println("课程:" + this.name + ",分数：" + this.score);for (GkAbstractCourse course : courseList) {for (int i = 0; i < level; i++) {System.out.print(" ");}System.out.print(">");course.info();}}
}

4、新建测试类来测试：

package com.zwx.design.pattern.composite.safe;public class TestSafe {public static void main(String[] args) throws Exception {CommonCource ywCourse = new CommonCource("语文", "150");CommonCource sxCourse = new CommonCource("数学", "150");CommonCource yyCourse = new CommonCource("英语", "150");CommonCource wlCourse = new CommonCource("物理", "110");CommonCource hxCourse = new CommonCource("化学", "100");CommonCource swCourse = new CommonCource("生物", "90");LevelCource lzCourse = new LevelCource("理综", "300", 2);lzCourse.addChild(wlCourse);lzCourse.addChild(hxCourse);lzCourse.addChild(swCourse);LevelCource gkCourse = new LevelCource("理科高考", "750", 1);gkCourse.addChild(ywCourse);gkCourse.addChild(sxCourse);gkCourse.addChild(yyCourse);gkCourse.addChild(lzCourse);gkCourse.info();}
}

这里和透明方式不一样，叶子节点不具备addChild功能，所以无法调用，而上面的示例中时可以被调用，但是调用之后显示不支持，这就是这两种写法最大的区别。

组合模式角色

从上面示例中，可以看到组合模式包含了以下三个角色：

• 抽象根节点(Component)：定义系统各层次对象的公有属性和方法，可以预先定义一些默认行为和属性。
• 树枝节点(Composite)：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
• 叶子节点(Leaf)：是系统遍历层次中的最小单位，下面没有子节点。

4、JDK 源码分析

Java 的集合类—— HashMap 就使用了组合模式

UML 类图

核心代码

// Component
public interface Map<K,V> {interface Entry<K,V> {}
}
public abstract class AbstractMap<K,V> implements Map<K,V> {}
// Composite
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {// Leafstatic class Node<K,V> implements Map.Entry<K,V> {}
}

说明

• 1）Map 就是一个抽象的构建，类似Component
• 2）HashMap 是一个中间的构建，类似Composite，实现 / 继承了相关方法 put、putAll
• 3）Node 是 HashMap 的静态内部类，类似Leaf叶子节点，这里就没有 put

5、注意事项和细节

• 1）简化客户端操作：客户端只需要面对一致的对象，而不用考虑整体部分或者节点叶子的问题
• 2）具有较强扩展性：当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动
• 3）方便创建复杂的层次结构：客户端不用理会组合里面的组成细节，容易添加节点或者叶子，从而创建出复杂的树形结构
• 4）需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式
• 5）要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式