《Head First 设计模式》（十一）：组合模式

清疚 2022-09-10 10:13 243阅读 0赞

## 1. 简介 ##

#### 1.1 定义 ####

> **组合模式（Composite Pattern） 也称为 整体-部分（Part-Whole）模式，将对象组合成树形结构以表示“部分整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。**

#### 1.2 组合模式抽象图 ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16]  
**根节点** 和 **树枝节点** 本质上是同一种数据类型，即都可以作为容器来使用。而 **叶子节点** 与 **树枝节点** 在语义上是不属于同一种数据类型的，但在组合模式中，是可以把树枝节点和叶子节点认为是同一种数据类型。即在组合模式中，整个树形结构中的对象都是同一种类型。

这样设计的便利就是可以让用户操作时，无需分别操作的对象是树枝节点还是叶子节点，就可以直接操作即可。

**关键：** **叶子节点** 与 **树枝节点** 实现同一接口，使叶子节点和树枝节点的操作具备一致性。

#### 1.3 组合模式角色构成 ####

*  **抽象接口（Component）**：为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式组合模式中还会声明访问和管理子类的接口。
 *  **树枝节点（Composite）**：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
 *  **叶子节点（Leaf）**：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

#### 1.4 组合模式的分类 ####

##### 1.4.1 透明模式 #####

**定义：** 在抽象接口声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。

**类图：**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
**优点：**

*  客户端无需分辨是叶子节点（Leaf）和树枝节点（Composite），它们具备完全一致的接口。

**缺点：**

*  叶子节点会继承一些不需要（管理子类操作的方法）的方法。

##### 1.4.2 安全模式 #####

**定义：**

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

**类图：**  
![·][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
**优点：**

*  接口定义职责清晰

**缺点：**

*  客户需要区分树枝节点（Composite）和叶子节点（Leaf），这样才能正确处理各个层次的操作

## 2. 代码例子 ##

#### 2.1 透明模式 ####

**抽象接口（Component）：**

package com.jbp.designpattern.composite;
    
    /** * @ClassName: Component * @description: 抽象接口 * @author: JiangBeiPing * @create: 2021-09-07 11:10 * @Version: 1.0 **/
    public abstract class Component { 
    
        public String name;
    
        public Component(String name){ 
            this.name = name;
        }
    
        public abstract String operation();
    
        public boolean addChild(Component component){ 
            throw new UnsupportedOperationException("addChild not supported!");
        }
    
        public boolean removeChild(Component component) { 
            throw new UnsupportedOperationException("removeChild not supported!");
        }
    
        public Component getChild(int index) { 
            throw new UnsupportedOperationException("getChild not supported!");
        }
    
    }

**树枝节点（Composite）：**

package com.jbp.designpattern.composite;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * @ClassName: Compositr * @description: 树枝节点 * @author: JiangBeiPing * @create: 2021-09-07 11:17 * @Version: 1.0 **/
    public class Composite extends Component{ 
    
        private List<Component> components;
    
        public Composite(String name) { 
            super(name);
            this.components = new ArrayList<>();
        }
    
        @Override
        public String operation() { 
            StringBuilder builder = new StringBuilder(this.name);
            for (Component component : components) { 
                builder.append("\n");
                builder.append(component.operation());
            }
            return builder.toString();
        }
    
        @Override
        public boolean addChild(Component component) { 
            return this.components.add(component);
        }
    
        @Override
        public boolean removeChild(Component component) { 
            return this.components.remove(component);
        }
    
        @Override
        public Component getChild(int index) { 
            return this.components.get(index);
        }
    }

**叶子节点（Leaf）：**

package com.jbp.designpattern.composite;
    
    /** * @ClassName: Leaf * @description: 叶子节点 * @author: JiangBeiPing * @create: 2021-09-07 11:25 * @Version: 1.0 **/
    public class Leaf extends Component{ 
    
        public Leaf(String name) { 
            super(name);
        }
    
        @Override
        public String operation() { 
            return this.name;
        }
    }

**测试：**

package com.jbp.designpattern.composite;
    
    /** * @ClassName: Client1 * @description: 透明模式测试 * @author: JiangBeiPing * @create: 2021-09-07 11:27 * @Version: 1.0 **/
    public class Client1 { 
        public static void main(String[] args) { 
            // 根节点
            Component root = new Composite("根节点");
            // 树枝节点
            Component branch1 = new Composite("=== 1号树枝节点");
            Component branch2 = new Composite("=== 2号树枝节点");
            // 叶子节点
            Component leaf1 = new Leaf("====== 1号叶子节点");
            Component leaf2 = new Leaf("====== 2号叶子节点");
            Component leaf3 = new Leaf("====== 3号叶子节点");
    
            root.addChild(branch1);
            root.addChild(branch2);
            branch1.addChild(leaf1);
            branch1.addChild(leaf2);
            branch2.addChild(leaf3);
    
            System.out.println(root.operation());
        }
    }

#### 2.2 安全模式 ####

只需要修改抽象接口层的方法，让原来的增删获取子节点方法转移到树枝节点即可。

客户端测试需要分别叶子节点和树枝节点

**抽象接口（Component）：**

## 3. 优缺点 ##

#### 3.1 优点 ####

*  高层模块调用简单
 *  节点自由增加
 *  客户端调用简单，客户端可以一致的使用组合结构或其中单个对象

#### 3.2 缺点 ####

*  在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/d5cbc4673a3e472a82062bc1ad268ad9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/c337449cf15742dd9a8494f291fac065.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Zuq5a2k5Z-O_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/d6e5ddc0bfed4c3e947e6d23a8da745d.png