目录

1，基本介绍：

2，组合模式的注意事项和细节

2.1 优点

2.2 缺点

3，模式的结构

3.1   透明方式

3.2  安全方式

4，模式实现：

4.1  透明组合模式

4.2  安全组合模式

5，组合模式应用实例：

6，组合模式在java HashMap源码中的应用

---

1，基本介绍：

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

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

3) 这种类型的设计模式属于结构型模式。

4) 组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。

由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用；而叶子节点与树枝节点在语义上不属于用一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。这样，在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利。

2，组合模式的注意事项和细节

2.1 优点

1. 简化客户端操作。组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象。
2. 具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动，满足“开闭原则”。
3. 方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构
4. 需要遍历组织机构，或者处理的对象具有树形结构时, 非常适合使用组合模式.

2.2 缺点

1. 要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式
2. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
3. 不容易限制容器中的构件；
4. 不容易用继承的方法来增加构件的新功能；

3，模式的结构

组合模式包含以下主要角色。

1. 抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）
2. 树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
3. 树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

如下图所示

        

组合模式分为透明式的组合模式和安全式的组合模式。

3.1   透明方式

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。

.

 

3.2  安全方式

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。

4，模式实现：

4.1  透明组合模式

下面为透明式的组合模式的实现代码。

public class CompositePattern {public static void main(String[] args) {Component c0 = new Composite();Component c1 = new Composite();Component leaf1 = new Leaf("1");Component leaf2 = new Leaf("2");Component leaf3 = new Leaf("3");c0.add(leaf1);c0.add(c1);c1.add(leaf2);c1.add(leaf3);c0.operation();}
}
//抽象构件
interface Component {public void add(Component c);public void remove(Component c);public Component getChild(int i);public void operation();
}
//树叶构件
class Leaf implements Component {private String name;public Leaf(String name) {this.name = name;}public void add(Component c) {}public void remove(Component c) {}public Component getChild(int i) {return null;}public void operation() {System.out.println("树叶" + name + "：被访问！");}
}
//树枝构件
class Composite implements Component {private ArrayList<Component> children = new ArrayList<Component>();public void add(Component c) {children.add(c);}public void remove(Component c) {children.remove(c);}public Component getChild(int i) {return children.get(i);}public void operation() {for (Object obj : children) {((Component) obj).operation();}}
}

4.2  安全组合模式

安全式的组合模式与透明式组合模式的实现代码类似，只要对其做简单修改就可以了，代码如下。

首先修改 Component 代码，只保留层次的公共行为。

interface Component {public void operation();
}

5，组合模式应用实例：

以学校和学院关系为例说明

示例代码：

1，定义接口：

//接口，组件
public interface OrganizationComponent {//添加组件void add(OrganizationComponent component);//删除组件void remove(OrganizationComponent component);//打印信息void print();
}

2，定义抽象类，实现接口

public abstract class Organization implements OrganizationComponent {//名称protected String name;//描述protected String des;public Organization(String name, String des) {this.name = name;this.des = des;}protected String getName() {return name;}protected String getDes() {return des;}@Overridepublic void add(OrganizationComponent component) {throw new UnsupportedOperationException();}@Overridepublic void remove(OrganizationComponent component) {throw new UnsupportedOperationException();}@Overridepublic void print() {}
}

3.定义大学，学院，系 （结构相似）

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;public class University extends Organization {List<OrganizationComponent> components = new ArrayList<>();public University(String name, String des) {super(name, des);}@Overridepublic void add(OrganizationComponent component) {components.add(component);}@Overridepublic void remove(OrganizationComponent component) {components.remove(component);}@Overridepublic void print() {List<String> collect = components.stream().map(item -> {Organization organization = (Organization) item;return organization.getName();}).collect(Collectors.toList());System.out.println("university " + super.getName() + "contains colleges : " + collect.toString());}
}public class College extends Organization{List<OrganizationComponent> components = new ArrayList<>();public College(String name, String des) {super(name, des);}@Overridepublic void add(OrganizationComponent component) {components.add(component);}@Overridepublic void remove(OrganizationComponent component) {components.remove(component);}@Overridepublic void print() {List<String> collect = components.stream().map(item -> {Organization organization = (Organization) item;return organization.getName();}).collect(Collectors.toList());System.out.println("college " + super.getName() + "contains department : " + collect.toString());}
}public class Department extends Organization {public Department(String name, String des) {super(name, des);}@Overridepublic void print() {System.out.println(super.getName());}
}

4，调用

public class Client {public static void main(String[] args) {//构建学校以及相关学院，系的组织树OrganizationComponent component = new University("西北农大","还不错");//构建学院OrganizationComponent computerCollege = new College("计算机学院","挺好");//构建系OrganizationComponent programmingDepartment = new Department("软件编程","牛逼");OrganizationComponent softwareDesignDepartment = new Department("软件设计","更牛逼");computerCollege.add(programmingDepartment);computerCollege.add(softwareDesignDepartment);programmingDepartment.print();System.out.println("========");OrganizationComponent informationCollege = new College("信工学院","挺好！！！");OrganizationComponent communicationDepartment = new Department("通信工程","好牛逼");OrganizationComponent communicationDesignDepartment = new Department("通信设计","更牛逼");informationCollege.add(communicationDepartment);informationCollege.add(communicationDesignDepartment);informationCollege.print();System.out.println("========");//组件学校component.add(computerCollege);component.add(informationCollege);component.print();}
}

6，组合模式在java HashMap源码中的应用

从下面 HashMap 类的简化源码，我们可以看到 putAll( ) 方法中传入的是 Map 对象。这里的 Map 就是一个抽象构件，同时这个构件只支持键值对的存储格式，而 HashMap 是一个中间构件，HashMap 中的 Node 节点就是叶子节点。

如下图UML类图：

 

部分源码如下：

1,定义接口Map，并且Map中定义方法

public interface Map<K, V> {//定义相关方法int size();boolean isEmpty();......
}

2,定义抽象类，并实现了Map方法

public abstract class AbstractMap<K,V> implements Map<K,V> {public int size() {return entrySet().size();}public boolean isEmpty() {return size() == 0;}
}

3,定义HashMap

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable {//HashMap中包含Node静态内部类 (叶子)static class Node<K,V> implements Map.Entry<K,V> {}public V put(K key, V value) {return putVal(hash(key), key, value, false, true);}//接受一个Mappublic void putAll(Map<? extends K, ? extends V> m) {putMapEntries(m, true);}
}