设计模式-结构型-08-组合模式

文章目录

    • 1、学校院系展示需求
    • 2、组合模式基本介绍
    • 3、组合模式示例
      • 3.1、 解决学校院系展示（透明模式1）
      • 3.2、高考的科目（透明模式2）
      • 3.3、高考的科目（安全组合模式）
    • 4、JDK 源码分析
    • 5、注意事项和细节

1、学校院系展示需求

编写程序展示一个学校院系结构：

需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图：
在这里插入图片描述
传统方式解决学校院系展示（类图）

在这里插入图片描述
问题分析

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

2、组合模式基本介绍

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

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

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

  • 4）组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象
    在这里插入图片描述
    对原理结构图的说明一即组合模式的角色及职责

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

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

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

解决的问题

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

在这里插入图片描述

3、组合模式示例

组合模式有两种写法，分别是透明模式和安全模式。

3.1、 解决学校院系展示（透明模式1）

UML 类图
在这里插入图片描述

核心代码

// Component 抽象类
public abstract class OrganizationComponent {
    private String name;

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

    public String getName() {
        return name;
    }

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

    public void add(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }

    public void remove(OrganizationComponent organizationComponent) {
        throw new UnsupportedOperationException();
    }

    public abstract void print();
}
// Composite 非叶子节点
public class University extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();

    public University(String name) {
        super(name);
    }

    @Override
    public void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }

    @Override
    public void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }

    @Override
    public void print() {
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
}
public class College extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();

    public College(String name) {
        super(name);
    }

    @Override
    public void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }

    @Override
    public void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }

    @Override
    public void print() {
        System.out.println("=============" + getName() + "=============");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
}
// Leaf 叶子结点
public class Major extends OrganizationComponent {
    public Major(String name) {
        super(name);
    }

    @Override
    public void print() {
        System.out.println(getName());
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        //大学
        OrganizationComponent university = new University("清华大学");
        //学院
        OrganizationComponent computerCollege = new College("计算机学院");
        OrganizationComponent infoEngineerCollege = new College("信息工程学院");
        //专业
        computerCollege.add(new Major("软件工程"));
        computerCollege.add(new Major("网络工程"));
        computerCollege.add(new Major("计算机科学与技术"));
        infoEngineerCollege.add(new Major("通信工程"));
        infoEngineerCollege.add(new Major("信息工程"));

        university.add(computerCollege);
        university.add(infoEngineerCollege);
        university.print();
    }
}

打印结果

  //=============计算机学院=============
        //软件工程
        //网络工程
        //计算机科学与技术
        //=============信息工程学院=============
        //通信工程
        //信息工程

3.2、高考的科目（透明模式2）

1、首先建立一个顶层的抽象科目类,这个类中定义了三个通用操作方法，但是均默认不支持操作

package com.zwx.design.pattern.composite.transparency;

/**
 * 顶层抽象组件
 */
public abstract class GkAbstractCourse {
    public void addChild(GkAbstractCourse course) {
        System.out.println("不支持添加操作");
    }

    public String getName() throws Exception {
        throw new Exception("不支持获取名称");
    }

    public void info() throws Exception {
        throw new Exception("不支持查询信息操作");
    }
}

PS：这个类中的公共方法之所以不定义为抽象方法的原因是因为假如定义为抽象方法，那么所有的子类都必须重写父类方法，这样体现不出差异性。而这种通过抛异常的方式，如果子类需要用到的功能就重写覆盖父类方法即可。

2、新建一个普通科目类继承通用科目抽象类，这个类作为叶子节点，没有重写addChild方法，也就是这个类属于叶子节点，不支持添加子节点：

package com.zwx.design.pattern.composite.transparency;

/**
 * 普通科目类(叶子节点)
 */
public class CommonCource extends GkAbstractCourse {
    private String name;
    private String score;

    public CommonCource(String name, String score) {
        this.name = name;
        this.score = score;
    }

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

    @Override
    public void info() {
        System.out.println("课程:" + this.name + ",分数:" + score);
    }
}

3、建立一个具有层级的节点，三个方法都重写了，支持添加子节点，这个类里面为了方便打印的时候看出层级关系，所以我定义了一个层级属性。

package com.zwx.design.pattern.composite.transparency;

import java.util.ArrayList;
import java.util.List;

/**
 * 树枝节点
 */
public class LevelCource extends GkAbstractCourse {
    private List<GkAbstractCourse> courseList = new ArrayList<>();
    private String name;
    private int level;

    public LevelCource(String name, int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void addChild(GkAbstractCourse course) {
        courseList.add(course);
    }

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

    @Override
    public void info() throws Exception {
        System.out.println("课程:" + this.name);
        for (GkAbstractCourse course : courseList) {
            for (int i = 0; i < level; i++) {
                System.out.print(" ");
            }
            System.out.print(">");
            course.info();
        }
    }
}

4、建立一个测试类来测试一下：

package com.zwx.design.pattern.composite.transparency;

public class TestTransparency {
    public static void main(String[] args) throws Exception {
        GkAbstractCourse ywCourse = new CommonCource("语文", "150");
        GkAbstractCourse sxCourse = new CommonCource("数学", "150");
        GkAbstractCourse yyCourse = new CommonCource("英语", "150");
        GkAbstractCourse wlCourse = new CommonCource("物理", "110");
        GkAbstractCourse hxCourse = new CommonCource("化学", "100");
        GkAbstractCourse swCourse = new CommonCource("生物", "90");
        GkAbstractCourse lzCourse = new LevelCource("理综", 2);
        lzCourse.addChild(wlCourse);
        lzCourse.addChild(hxCourse);
        lzCourse.addChild(swCourse);
        GkAbstractCourse gkCourse = new LevelCource("理科高考科目", 1);
        gkCourse.addChild(ywCourse);
        gkCourse.addChild(sxCourse);
        gkCourse.addChild(yyCourse);
        gkCourse.addChild(lzCourse);
        gkCourse.info();
    }
}

输出结果：

课程:理科高考科目  
> 课程:语文,分数:150  
> 课程:数学,分数:150  
> 课程:英语,分数:150  
> 课程:理综  
     >课程:物理,分数:110  
     >课程:化学,分数:100  
     >课程:生物,分数:90

这里如果用普通科目去调用add方法就会抛出异常，假如上面调用：

swCourse.addChild(ywCourse);

会输出

不支持添加操作

因为在普通科目类里面并没有重写addChild方法。

透明组合模式的缺陷

透明模式的特点就是将组合对象所有的公共方法都定义在了抽象组件内，这样做的好处是客户端无需分辨当前对象是属于树枝节点还是叶子节点，因为它们具备了完全一致的接口，不过缺点就是叶子节点得到到了一些不属于它的方法，比如上面的addChild方法，这违背了接口隔离性原则。

3.3、高考的科目（安全组合模式）

安全组合模式只是规定了系统各个层次的最基础的一致性行为，而把组合(树节点)本身的方法(如树枝节点管理子类的addChild等方法)放到自身当中。

1、首先还是建立一个顶层的抽象根节点(这里面只定义了一个通用的抽象info方法)：

package com.zwx.design.pattern.composite.safe;package com.zwx.design.pattern.composite.safe;

/**
 * 顶层抽象组件
 */
public abstract class GkAbstractCourse {
    protected String name;
    protected String score;

    public GkAbstractCourse(String name, String score) {
        this.name = name;
        this.score = score;
    }

    public abstract void info();
}

2、建立一个叶子节点（这里只是重写了info方法，没有定义其他特有方法）：

package com.zwx.design.pattern.composite.safe;

/**
 * 叶子节点
 */
public class CommonCource extends GkAbstractCourse {
    public CommonCource(String name, String score) {
        super(name, score);
    }

    @Override
    public void info() {
        System.out.println("课程:" + this.name + ",分数:" + this.score);
    }
}

3、定义一个树枝节点（这个类当中定义了一个树枝特有的方法addChild）：

package com.zwx.design.pattern.composite.safe;

import java.util.ArrayList;
import java.util.List;

/**
 * 树枝节点
 */
public class LevelCource extends GkAbstractCourse {
    private List<GkAbstractCourse> courseList = new ArrayList<>();
    private int level;

    public LevelCource(String name, String score, int level) {
        super(name, score);
        this.level = level;
    }

    public void addChild(GkAbstractCourse course) {
        courseList.add(course);
    }

    @Override
    public void info() {
        System.out.println("课程:" + this.name + ",分数：" + this.score);
        for (GkAbstractCourse course : courseList) {
            for (int i = 0; i < level; i++) {
                System.out.print(" ");
            }
            System.out.print(">");
            course.info();
        }
    }
}

4、新建测试类来测试：

package com.zwx.design.pattern.composite.safe;

public class TestSafe {
    public static void main(String[] args) throws Exception {
        CommonCource ywCourse = new CommonCource("语文", "150");
        CommonCource sxCourse = new CommonCource("数学", "150");
        CommonCource yyCourse = new CommonCource("英语", "150");
        CommonCource wlCourse = new CommonCource("物理", "110");
        CommonCource hxCourse = new CommonCource("化学", "100");
        CommonCource swCourse = new CommonCource("生物", "90");
        LevelCource lzCourse = new LevelCource("理综", "300", 2);
        lzCourse.addChild(wlCourse);
        lzCourse.addChild(hxCourse);
        lzCourse.addChild(swCourse);
        LevelCource gkCourse = new LevelCource("理科高考", "750", 1);
        gkCourse.addChild(ywCourse);
        gkCourse.addChild(sxCourse);
        gkCourse.addChild(yyCourse);
        gkCourse.addChild(lzCourse);
        gkCourse.info();
    }
}

这里和透明方式不一样，叶子节点不具备addChild功能，所以无法调用，而上面的示例中时可以被调用，但是调用之后显示不支持，这就是这两种写法最大的区别。

组合模式角色

从上面示例中，可以看到组合模式包含了以下三个角色：

  • 抽象根节点(Component)：定义系统各层次对象的公有属性和方法，可以预先定义一些默认行为和属性。
  • 树枝节点(Composite)：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
  • 叶子节点(Leaf)：是系统遍历层次中的最小单位，下面没有子节点。

4、JDK 源码分析

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

UML 类图

在这里插入图片描述
核心代码

// Component
public interface Map<K,V> {
    interface Entry<K,V> {}
}
public abstract class AbstractMap<K,V> implements Map<K,V> {}
// Composite
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // Leaf
    static class Node<K,V> implements Map.Entry<K,V> {}
}

说明

  • 1）Map 就是一个抽象的构建，类似Component
  • 2）HashMap 是一个中间的构建，类似Composite，实现 / 继承了相关方法 put、putAll
  • 3）Node 是 HashMap 的静态内部类，类似Leaf叶子节点，这里就没有 put

5、注意事项和细节

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/767483.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

MySQL之应用层优化(二)

MySQL之应用层优化(二)

应用层优化 Web服务器问题 寻找最优并发度 每个Web服务器都有一个最佳并发度——就是说&#xff0c;让进程处理请求尽可能快&#xff0c;并且不超过系统负载的最优的并发连接数。这就是前面说的最大系统容量。进行一个简单的测量和建模&#xff0c;或者只是反复试验&#xf…
阅读更多...
Python基础入门知识

Python基础入门知识

目录 引言 简要介绍Python语言 为什么要学习Python Python的应用领域 Python安装和环境配置 Python的下载和安装（Windows, macOS, Linux） 配置Python环境变量 安装和使用IDE（如PyCharm, VS Code） Python基本语法 注释 变量和数据类型（数字，字符串，列表，元组，字典，…
阅读更多...
互联网医院系统源码解析：如何打造智能数字药店APP？

互联网医院系统源码解析：如何打造智能数字药店APP？

在互联网技术飞速发展的今天&#xff0c;医疗行业也在不断与之融合&#xff0c;互联网医院系统应运而生。特别是智能数字药店APP的兴起&#xff0c;使得医疗服务变得更加便捷、高效。本文将深入解析互联网医院系统源码&#xff0c;探讨如何打造一个智能的数字药店APP。 一、互…
阅读更多...
思维，CF 739A - Alyona and mex

思维，CF 739A - Alyona and mex

一、题目 1、题目描述 2、输入输出 2.1输入 2.2输出 3、原题链接 739A - Alyona and mex 二、解题报告 1、思路分析 我们考虑区间mex运算的值最大也就是区间长度&#xff0c;所以我们最大值的上界就是所有区间中的最小长度&#xff0c;假如记为mi 我们一定可以构造出答案…
阅读更多...
【C++】const详解

【C++】const详解

&#x1f4e2;博客主页&#xff1a;https://blog.csdn.net/2301_779549673 &#x1f4e2;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01; &#x1f4e2;本文作为 JohnKi &#xff0c;引用了部分大佬的案例 &#x1f4e2;未来很长&#xff0c;…
阅读更多...
RabbitMQ 更改服务端口号

RabbitMQ 更改服务端口号

需求 windows环境下&#xff0c;将RabbitMQ默认的端口号 5672 改为 11001 实现 本机RabbitMQ版本为3.8.16&#xff0c;找到配置文件位置&#xff0c;路径为&#xff1a;C:\Users\%USERNAME%\AppData\Roaming\RabbitMQ\advanced.config 配置文件默认内容为空 填写修改端口号…
阅读更多...
QGC添加添加QML可访问的单例

QGC添加添加QML可访问的单例

文章目录 前言一、添加文件二、修改qgroundcontrol.pro三、修改QGCApplication.cc四、修改QGroundControlQmlGlobal.h五、修改QGroundControlQmlGlobal.cc六、测试前言 QGC 4.2 一、添加文件 在src目录下添加文件夹SingletonTest，在里面新建SingletonTest.cc和SingletonTes…
阅读更多...
【Sklearn-驯化】一文搞懂很难的EM算法以及实践

【Sklearn-驯化】一文搞懂很难的EM算法以及实践

【Sklearn-驯化】一文搞懂很难的EM算法以及实践 本次修炼方法请往下查看 &#x1f308; 欢迎莅临我的个人主页 &#x1f448;这里是我工作、学习、实践 IT领域、真诚分享 踩坑集合&#xff0c;智慧小天地&#xff01; &#x1f387; 免费获取相关内容文档关注&#xff1a;微信公…
阅读更多...
Unity扩展 Text支持超链接文本

Unity扩展 Text支持超链接文本

重点提示&#xff1a;当前的文本扩展支持多个超链接&#xff0c;支持修改超链接规则和支持修改超链接颜色。 近期在邮件文本中用到了超链接。最初是在邮件窗口中新加一个按钮用来超链接跳转&#xff0c;之后发现效果表现不如直接在文本中添加&#xff0c;后经过几个小时的资料…
阅读更多...
两步解决Hugging Face下载模型速度慢/连接超时/无法下载问题

两步解决Hugging Face下载模型速度慢/连接超时/无法下载问题

博主使用的配置是 x86_64 Linux服务器 第一步设置代理镜像： export HF_ENDPOINT=https://hf-mirror.com 第二步（使用代码时，删除引号）： --token参数表示下载的模型是否需要登录验证（部分模型需要token） huggingface-cli download --token "获取的hf_*******token…
阅读更多...
如何选择优质模型？SD3性能究竟如何？

如何选择优质模型？SD3性能究竟如何？

遇到难题不要怕&#xff01;厚德提问大佬答&#xff01; 厚德提问大佬答12 厚德提问大佬答第十二期 你是否对AI绘画感兴趣却无从下手&#xff1f;是否有很多疑问却苦于没有大佬解答带你飞&#xff1f;从此刻开始这些问题都将迎刃而解&#xff01;你感兴趣的话题&#xff0c;厚德…
阅读更多...
vivado联合modelsim仿真

vivado联合modelsim仿真

一. 编译Vivado仿真库 打开Vivado&#xff0c;Tools -> Compile Simulation Libraries 二. 设置仿真工具和库路径 因为新建工程的默认仿真工具是Vivado Simulator&#xff0c;所以要使用Modelsim仿真&#xff0c;每个新工程都要设置一次&#xff0c;方法如下&#xff1a; …
阅读更多...
2024年【安全生产监管人员】考试题及安全生产监管人员试题及解析

2024年【安全生产监管人员】考试题及安全生产监管人员试题及解析

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 安全生产监管人员考试题根据新安全生产监管人员考试大纲要求&#xff0c;安全生产模拟考试一点通将安全生产监管人员模拟考试试题进行汇编&#xff0c;组成一套安全生产监管人员全真模拟考试试题&#xff0c;学员可通…
阅读更多...
现代工作场所中的睡岗检测算法应用

现代工作场所中的睡岗检测算法应用

在现代职场环境中&#xff0c;员工的工作状态直接影响到公司的整体效益。睡岗现象&#xff0c;即员工在工作时间内打瞌睡或睡觉&#xff0c;不仅降低了生产力&#xff0c;还可能带来安全隐患。因此&#xff0c;如何有效地检测和预防睡岗行为成为了企业管理中的一个重要课题。随…
阅读更多...
真的，今年我劝各位真的别轻易离职

真的，今年我劝各位真的别轻易离职

前言 在当前的职业浪潮中&#xff0c;把握时机深入学习大模型技术无疑是明智之举。随着行业对这类专业人才的渴求日益增长&#xff0c;无论是巨头企业还是新兴初创&#xff0c;都在加速推进大模型的应用实践&#xff0c;而真正能将技术有效落地并转化为业务价值的专家却供不应…
阅读更多...
详细解释下flutter初始示例的代码

详细解释下flutter初始示例的代码

详细解释下flutter初始示例的代码 main 首句导入需要的包 类似于其他语言的import main函数为入口函数 包裹MyApp类 MyApp 这个类继承自无状态类 可见myapp不管理任何状态 build方法是所有widget内必须实现的方法 此处返回一个 ChangeNotferiProvider 可以看到它用于管理应…
阅读更多...
理解 REST API 和 GraphQL 的区别

理解 REST API 和 GraphQL 的区别

你可能听说过 GraphQL&#xff0c;但对它与 REST 的区别还不完全确定。今天我们将介绍 REST 和 GraphQL 的一些基本原理&#xff0c;以及它们的不同使用场景。 GraphQL 作为 REST API 的替代品越来越受欢迎&#xff0c;不过它不一定是完全的“替代品”。 根据你的使用情景&am…
阅读更多...
LLM笔记：训练大模型之并行化

LLM笔记：训练大模型之并行化

1 数据并行 最常见的并行化手段主要是把数据分成多个块&#xff0c;然后每个节点就可以在本地独立的跑各自的数据任务&#xff0c;最后再和其他节点通信&#xff0c;进而汇总最后的结果好处就是计算效率高&#xff0c;每个节点可以独自计算自己的任务且这种方法易于实现缺点就…
阅读更多...
【Python基础篇】一篇文章入门Python，进入Python的世界

【Python基础篇】一篇文章入门Python，进入Python的世界

文章目录 0.前言1.打印&#xff08;Hello&#xff0c;World&#xff09;2.创建变量3.打印升级3.1 打印一句话中间加变量3.2 sep设置分隔符3.3 end和换行 4. 注释 0.前言 大家好&#xff0c;我是小辰&#xff0c;前几天做了个重大的决定&#xff0c;学习python。 首先&#xff0…
阅读更多...
博途S7-1500PLC“虚轴“编程应用

博途S7-1500PLC“虚轴“编程应用

1、CODESYS如何添加虚轴 如何添加虚轴(AM400PLC)-CSDN博客文章浏览阅读164次。EtherCAT运动控制总线启用的时候，选择EtherCAT总线任务周期。选择好后，选择点击添加。https://rxxw-control.blog.csdn.net/article/details/139898985虚轴是利用软件算法实现的运动控制轨迹规划…
阅读更多...
最新文章

Copyright @ 2022~2023