设计模式（七）之结构型模式-组合模式

发表于 | 阅读次数:
字数统计: 2.2k | 阅读时长 ≈ 9

一、组合模式

1、案例分析

学校院系展示需求：

​ 编写程序展示一个学校院系结构：需求如下：要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如下图：

image-20210714000320952

1.1.1 传统方案

传统方案：学校由学院组成，学院由系组成

image-20210712232905597

1.1.2 传统方案存在问题

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

2、组合模式

  • 定义：组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示”整体-部分”的层次关系。
  • 组合模式依据属性结构来组合对象，用来表示部分以及整体层次
  • 组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。

2.1 组合模式原理类图

image-20210713230011720

  • Component：这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为，用于访问和管理Component子部件，Component可以是抽象类或者接口
  • Leaf：在组合中表示叶子节点，叶子节点没有子节点
  • Composite：非叶子节点，用于存储子部件，在Component接口中实现子部件的相关操作，比如增加（add）、删除。

2.2 组合模式解决的问题

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

3、代码实例

将前面的案例，使用组合模式，则如下图所示：

  1. OrganizationComponent是一个抽象类
  2. University继承OrganizationComponent，内聚了OrganizationComponent对象，属于Composite
  3. College继承OrganizationComponent，内聚了OrganizationComponent对象，属于Composite
  4. Department继承OrganizationComponent，只使用了print方法。属于Leaf

image-20210714001353553

3.1 OrganizationComponent类

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
31
32
33
34
35
36
37
38
public abstract class OrganizationComponent {
    private String name;//名字
    private String des;//说明

    public OrganizationComponent(String name, String des) {
        super();
        this.name = name;
        this.des = des;
    }

    protected void add(OrganizationComponent organizationComponent){
        //默认实现
        throw new UnsupportedOperationException();
    }

    protected void remove(OrganizationComponent organizationComponent){
        //默认实现
        throw new UnsupportedOperationException();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }
    //方法print，做成抽象的，子类都需要实现
    protected abstract void print();
}

3.2 University类

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.ArrayList;
import java.util.List;

//University 就是Composite，可以管理college
public class University extends OrganizationComponent {

    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();

    //构造器
    public University(String name, String des) {
        super(name, des);
    }

    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

    //重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    //print方法，就是输出university包含的学院
    @Override
    protected void print() {
        System.out.println("----------------------"+getName()+"-----------------------");
        //遍历organizationComponents
        for (OrganizationComponent organizationComponent:organizationComponents){
            organizationComponent.print();
        }
    }
}

3.3 College类

其实College和University在代码本质上是差不多的，为什么不在抽象一个类，而又重新写一遍？

  • 因为将来实际业务中，college的add和university中的add不一定完全一样
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
31
32
33
34
35
36
37
38
39
40
41
42
43
public class College extends OrganizationComponent {

    //list中存放的是department
    List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();

    //构造器
    public College(String name, String des) {
        super(name, des);
    }

    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        //将来实际业务中，college的add和university中的add不一定完全一样
        organizationComponents.add(organizationComponent);
    }

    //重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponentssss.remove(organizationComponent);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    //print方法，就是输出college包含的系
    @Override
    protected void print() {
        System.out.println("----------------------"+getName()+"-----------------------");
        //遍历organizationComponents
        for (OrganizationComponent organizationComponent:organizationComponents){
            organizationComponent.print();
        }
    }
}

3.4 Department类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Department extends OrganizationComponent {

    public Department(String name, String des) {
        super(name, des);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public String getDes() {
        return super.getDes();
    }

    //add,remove就不用写了，因为他是叶子节点
    @Override
    protected void print() {
        System.out.println(getName());
    }
}

3.5 Client类

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
public class Client {
    public static void main(String[] args) {
        //从大到小创建对象
        OrganizationComponent university = new University("清华大学","中国顶级大学");

        //创建学院
        OrganizationComponent computerCollege = new College("计算机学院", "计算机学院");
        OrganizationComponent infoEngineerCollege = new College("信息工程学院", "信息工程学院");

        //创建各个学院下面的系（专业）
        computerCollege.add(new Department("软件工程","软件工程不错"));
        computerCollege.add(new Department("网络工程","网络工程不错"));
        computerCollege.add(new Department("计算机科学与技术","计算机科学与技术是老牌的专业"));

        //信息工程学院添加专业
        infoEngineerCollege.add(new Department("通信工程","通信工程不好学"));
        infoEngineerCollege.add(new Department("信息工程","信息工程好学"));

        //将学院加入到学校
        university.add(computerCollege);
        university.add(infoEngineerCollege);

        university.print();//输出学校
        System.out.println("====================================");
        computerCollege.print();//输出某个学院

    }
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
----------------------清华大学-----------------------
----------------------计算机学院-----------------------
软件工程
网络工程
计算机科学与技术
----------------------信息工程学院-----------------------
通信工程
信息工程
====================================
----------------------计算机学院-----------------------
软件工程
网络工程
计算机科学与技术

分析：

  • 通过组合模式，我们就可以很好的输出学校和学院的组合结构了。

4、组合模式在JDK集合中的源码分析—HashMap

4.1 简单代码示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.HashMap;
import java.util.Map;

public class Composite {
    public static void main(String[] args) {
        //说明
        //1.Map就是一个抽象的构建（类似我们的Component）
        //2.HashMap是一个中间的构建（Composite），实现/继承了相关方法 put\putAll
        //3. Node是HashMap的静态内部类，类似Leaf叶子节点，这里就没有put\putAll
        Map<Integer,String> hashMap = new HashMap<Integer,String>();
        hashMap.put(0,"东游记");//直接存放叶子节点
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(1,"西游记");
        map.put(2,"红楼梦");
        hashMap.putAll(map);
        System.out.println(hashMap);
    }
}

结果：

1
{0=东游记, 1=西游记, 2=红楼梦}

4.2 源码分析

  1. Map就相当于组合模式中的Component，打开Map的接口发现，Map是一个接口，并且有put和putAll两个方法；

    image-20210714223637027

  2. Map的子类有：AbstractMap（抽象类）

    image-20210714223845657

    AbstractMap类中的put方法如下：

    1
    2
    3
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }

    该方法是一个默认方法，需要由其子类来实现

  3. AbstractMap的子类有：HashMap

    image-20210714224251190

    HashMap：具体的Composite

    AbstractMap和Map就可以看做是Component，抽象层

    1
    2
    3
    public class HashMap<K,V> extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable {
    }

    HashMap中有个Node类，相当于组合模式中的Leaf（叶子节点）

    1
    static class Node<K,V> implements Map.Entry<K,V> {}

    HashMap的put方法

    1
    2
    3
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    put方法中的putVal详情如下：也会用一个Node节点来存放key和value

    image-20210714225031093

4.3 源码的类图

image-20210714225725422

5、组合模式的注意事项和细节

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