汶泽的世界
large picture of the cover

设计模式：08-组合模式

1、学院院系展示需求

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

清华大学
|__计算机学院
    |__计算机科学与技术
    |__软件工程
    |__网络工程
|__信息工程学院
    |__通信工程
    |__信息工程

2、传统方案解决学校院系展示

2.1 类图

7zta4

2.2 存在的问题分析

1）将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的

2）实际上我们的要求是：在一个页面中展示出学院的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等

3）解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作 => 组合模式

3、组合模式

3.1 基本介绍

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

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

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

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

3.2 原理类图

3pi5q

说明（角色及职责）：

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

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

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

3.3 解决的问题

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

2）对应的示意图：

x9afk

3.4 应用实例

1）要求

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系

2）思路分析（类图）

dibla

3）代码实现

OrganizationComponent 组织机构抽象类

package com.wenze.design.composite;  
  
import lombok.Getter;  
import lombok.Setter;  
  
/**  
 * 组织抽象类  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-27 11:48:25  
 * @since 1.0  
 */
@Setter  
@Getter  
public abstract class OrganizationComponent {  
    /**  
     * 名字  
     */  
    private String name;  
    /**  
     * 说明  
     */  
    private String description;  
    public OrganizationComponent(final String name, final String description) {  
        this.name = name;  
        this.description = description;  
    }  
    protected void add(OrganizationComponent component) {  
        // 默认实现  
        throw new UnsupportedOperationException();  
    }  
    protected void remove(OrganizationComponent component) {  
        // 默认实现  
        throw new UnsupportedOperationException();  
    }  
    protected abstract void print();  
}

University 学校

package com.wenze.design.composite;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/**  
 * 学校  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-27 11:53:15  
 * @since 1.0  
 */
public class University extends OrganizationComponent {  
    /**  
     * 院校集合  
     */  
    private List<OrganizationComponent> organizationComponents = new ArrayList<>();  
    public University(final String name, final String description) {  
        super(name, description);  
    }  
    @Override  
    protected void add(final OrganizationComponent component) {  
        organizationComponents.add(component);  
    }  
    @Override  
    protected void remove(final OrganizationComponent component) {  
        organizationComponents.remove(component);  
    }  
    @Override  
    public String getName() {  
        return super.getName();  
    }  
    @Override  
    public String getDescription() {  
        return super.getDescription();  
    }  
    @Override  
    protected void print() {  
        System.out.println("------------" + getName() + "------------");  
        organizationComponents.forEach(OrganizationComponent::print);  
    }  
}

College 学院

package com.wenze.design.composite;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/**  
 * 院校  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-27 11:56:48  
 * @since 1.0  
 */
public class College extends OrganizationComponent {  
    /**  
     * 系集合  
     */  
    private List<OrganizationComponent> organizationComponents = new ArrayList<>();  
    public College(final String name, final String description) {  
        super(name, description);  
    }  
    @Override  
    protected void add(final OrganizationComponent component) {  
        organizationComponents.add(component);  
    }  
    @Override  
    protected void remove(final OrganizationComponent component) {  
        organizationComponents.remove(component);  
    }  
    @Override  
    public String getName() {  
        return super.getName();  
    }  
    @Override  
    public String getDescription() {  
        return super.getDescription();  
    }  
    @Override  
    protected void print() {  
        System.out.println("------------" + getName() + "------------");
        organizationComponents.forEach(OrganizationComponent::print);  
    }  
}

Department 系

package com.wenze.design.composite;  
  
/**  
 * 系  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-27 11:58:48  
 * @since 1.0  
 */
public class Department extends OrganizationComponent {  
    public Department(final String name, final String description) {  
        super(name, description);  
    }  
    @Override  
    public String getName() {  
        return super.getName();  
    }  
    @Override  
    public String getDescription() {  
        return super.getDescription();  
    }  
    @Override  
    protected void print() {  
        System.out.println(getName());  
    }  
}

Client 客户端

package com.wenze.design.composite;  
  
/**  
 * 客户端  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-27 11:59:58  
 * @since 1.0  
 */
public class Client {  
    public static void main(String[] args) {  
        // 从大到小创建对象  
		
        // 学校  
        final OrganizationComponent university = new University("清华大学", "中国顶级大学");  
		
        // 学院  
        final OrganizationComponent computerCollege = new College("计算机学院", "计算机学院");  
        final OrganizationComponent infoEngineerCollege = new College("信息工程学院", "信息工程学院");  
		
        // 系  
        final OrganizationComponent computerDepartment = new Department("计算机科学与技术", "计算机科学与技术");  
        final OrganizationComponent softwareEngineerDepartment = new Department("软件工程", "软件工程");  
        final OrganizationComponent networkEngineeringDepartment = new Department("网络工程", "网络工程");  
        final OrganizationComponent informationSecurityDepartment = new Department("信息安全", "信息安全");  
		
        final OrganizationComponent informationEngineeringDepartment = new Department("信息工程", "信息工程");  
        final OrganizationComponent communicationEngineeringDepartment = new Department("通信工程", "通信工程");  
		
        // 将系加入学院  
        computerCollege.add(computerDepartment);  
        computerCollege.add(softwareEngineerDepartment);  
        computerCollege.add(networkEngineeringDepartment);  
        computerCollege.add(informationSecurityDepartment);  
		  
        infoEngineerCollege.add(informationEngineeringDepartment);  
        infoEngineerCollege.add(communicationEngineeringDepartment);  
		
        // 将学院加入学校  
        university.add(computerCollege);  
        university.add(infoEngineerCollege);  
		
        university.print();  
    }  
}

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

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

2）代码分析 + Debug 源码

mgyz1

i5bj3

3）类图分析

dslwu

说明：

  1. Map 就是一个抽象的构建（类似我们的 Component）
  2. HashMap 是一个中间的构建（Composite），实现/继承了相关方法，put、putAll
  3. Node 是 HashMap 的静态内部类，类似 Leaf 叶子节点，这里就没有 put、putAll。static class Node<K,V> implements Map.Entry<K,V>

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

1）简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。

2）具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动。

3）方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构

4）需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式。

5）要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式。

site logo

欢迎来到汶泽的世界

© 2024 汶泽的世界