# 《Java极简设计模式》第11章：组合模式（Composite）

作者：冰河
星球：http://m6z.cn/6aeFbs (opens new window)
博客：https://binghe.gitcode.host (opens new window)
文章汇总：https://binghe.gitcode.host/md/all/all.html (opens new window)
源码地址：https://github.com/binghe001/java-simple-design-patterns/tree/master/java-simple-design-composite (opens new window)

沉淀，成长，突破，帮助他人，成就自我。

本章难度：★★☆☆☆
本章重点：用最简短的篇幅介绍组合模式最核心的知识，理解组合模式的设计精髓，并能够灵活运用到实际项目中，编写可维护的代码。

大家好，我是CurleyG~~

今天给大家介绍《Java极简设计模式》的第11章，组合模式（Composite），多一句没有，少一句不行，用最简短的篇幅讲述设计模式最核心的知识，好了，开始今天的内容。

# 一、概述

将对象组合成树形结构以表示"部分-整体"的层次结构。"Composite使得用户对单个对象和组合对象的使用具有一致性。

# 二、适用性

1.表示对象的部分-整体层次结构。

2.忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象。

# 三、参与者

1.Component 为组合中的对象声明接口。在适当的情况下，实现所有类共有接口的缺省行为。声明一个接口用于访问和管理Component的子组件。 (可选)在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。

2.Leaf 在组合中表示叶节点对象，叶节点没有子节点。在组合中定义节点对象的行为。

3.Composite 定义子部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。

4.Client 通过Component接口操纵组合部件的对象。

# 四、类图

# 五、示例

Component

/**
 * @author binghe(微信 : hacker_binghe)
 * @version 1.0.0
 * @description 定义Component 类Employer
 * @github https://github.com/binghe001
 * @copyright 公众号: 冰河技术
 */
public abstract class Employer {

    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public abstract void add(Employer employer);

    public abstract void delete(Employer employer);

    public List<Employer> employers;

    public void printInfo() {
        System.out.println(name);
    }

    public List<Employer> getEmployers() {
        return this.employers;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Leaf

/**
 * @author binghe(微信 : hacker_binghe)
 * @version 1.0.0
 * @description 定义Leaf类Programmer
 * @github https://github.com/binghe001
 * @copyright 公众号: 冰河技术
 */
public class Programmer extends Employer {

    public Programmer(String name) {
        setName(name);
        //程序员, 表示没有下属了
        employers = null;
    }
    public void add(Employer employer) {
    }

    public void delete(Employer employer) {
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @author binghe(微信 : hacker_binghe)
 * @version 1.0.0
 * @description 定义Leaf类ProjectAssistant
 * @github https://github.com/binghe001
 * @copyright 公众号: 冰河技术
 */
public class ProjectAssistant  extends Employer {

    public ProjectAssistant(String name) {
        setName(name);
        //项目助理, 表示没有下属了
        employers = null;
    }
    public void add(Employer employer) {

    }

    public void delete(Employer employer) {

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Composite

/**
 * @author binghe(微信 : hacker_binghe)
 * @version 1.0.0
 * @description 定义Composite类ProjectManager类
 * @github https://github.com/binghe001
 * @copyright 公众号: 冰河技术
 */
public class ProjectManager extends Employer {

    public ProjectManager(String name) {
        setName(name);
        employers = new ArrayList<>();
    }

    public void add(Employer employer) {
        employers.add(employer);
    }

    public void delete(Employer employer) {
        employers.remove(employer);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Test

/**
 * @author binghe(微信 : hacker_binghe)
 * @version 1.0.0
 * @description 测试类
 * @github https://github.com/binghe001
 * @copyright 公众号: 冰河技术
 */
public class Test {

    public static void main(String[] args) {
        Employer pm = new ProjectManager("项目经理");
        Employer pa = new ProjectAssistant("项目助理");
        Employer programmer1 = new Programmer("程序员一");
        Employer programmer2 = new Programmer("程序员二");
        //为项目经理添加项目助理
        pm.add(pa);
        //为项目经理添加程序员
        pm.add(programmer1);
        pm.add(programmer2);

        List<Employer> ems = pm.getEmployers();
        for (Employer em : ems) {
            System.out.println(em.getName());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Result

项目助理
程序员一
程序员二

1
2
3

好了，今天就到这儿吧，相信大家对组合模式有了更清晰的了解，我是冰河，我们下期见~~

← 第10章：桥接模式第12章：享元模式 →