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

news2024/11/24 15:25:51

文章目录

    • 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）要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

33.哀家要长脑子了！

33.哀家要长脑子了！

憋说了&#xff0c;感觉好不容易长出来的脑子又缩回去了。。。 1.539. 最小时间差 - 力扣&#xff08;LeetCode&#xff09; 把所有时间排好序&#xff0c;然后计算两两之间的分钟差就好&#xff0c;但是要注意加上最后一个和第一个的判断&#xff0c;因为这个时间是按字典序来…
阅读更多...
python-切片、集合

python-切片、集合

序列是指&#xff1a;内容连续、有序&#xff0c;可使用下标索引的一类数据容器 序列的常用操作 - 切片 切片的语法 序列的常用操作 - 切片 注意切片的范围是左闭右开 为什么使用集合 集合的常用操作 - 修改 集合的常用操作 - 集合长度 集合常用功能总结 集合的特点
阅读更多...
为RK3568或RK3288开发板创建交叉编译环境{采用amd64的ubuntu系统配置交叉编译arm64开发环境}(保姆级包括安装QT)超详细记录版

为RK3568或RK3288开发板创建交叉编译环境{采用amd64的ubuntu系统配置交叉编译arm64开发环境}(保姆级包括安装QT)超详细记录版

为RK3568或RK3288开发板创建交叉编译环境{采用amd64的ubuntu系统配置交叉编译arm64开发环境}【保姆级包括安装QT】超详细记录版 Chapter1 为RK3568或RK3288开发板创建交叉编译环境{采用amd64的ubuntu系统配置交叉编译arm64开发环境}(保姆级包括安装QT)超详细记录版一. 安装QT程…
阅读更多...
严防数据泄露：风险评估来预警，自查自纠防患未然！

严防数据泄露：风险评估来预警，自查自纠防患未然！

近年来&#xff0c;随着数字化和网络化的快速发展&#xff0c;数据泄露事件呈现高发态势。网络攻击者利用复杂的攻击手段和技术&#xff0c;不断寻找和利用系统中的漏洞&#xff0c;以窃取或破坏数据&#xff0c;对企业声誉、客户信任以及经济利益造成巨大影响。 一、数据泄露的…
阅读更多...
提升船舶轨迹查询效率

提升船舶轨迹查询效率

文章目录 引言I 优化思路1.1 表结构设计1.2 解析请求参数，定位到对应的表格进行查询1.3 mybatis查询1.4 效果II 工具方法2.1 日期处理2.2 spring开启debug日志引言 需求： 查询船舶轨迹 I 优化思路 1.1 表结构设计 按天存储轨迹数据，本文是一个月存储在6在表中，即：01，06…
阅读更多...
Windows Hello | 看起来您已经在另一个帐户上设置了 Windows Hello。

Windows Hello | 看起来您已经在另一个帐户上设置了 Windows Hello。

问题&#xff1a; 换了新电脑之后一直设置不了Window Hello&#xff0c;报错是 "it looks like youve already setup Windows Hello on another account."。 >>重复set up不行。 >>从旧电脑移除了Windows Hello设置也不行。 >>确认过我的Local…
阅读更多...
自闭症学生的刻板行为表现与教育干预策略

自闭症学生的刻板行为表现与教育干预策略

在自闭症学校的日常教学中&#xff0c;我深刻体会到刻板行为是许多学生常见且显著的特征之一。这些行为不仅影响学生的学习效果&#xff0c;也是他们与外界沟通互动的一大障碍。 刻板行为首先体现在动作上&#xff0c;学生们可能会反复进行某些无意义的动作&#xff0c;如摇晃身…
阅读更多...
如何实现在短信链接中直接打开微信小程序

如何实现在短信链接中直接打开微信小程序

你是否有过这样的体验&#xff0c;收到一条短信&#xff0c;里面有一个链接&#xff0c;点击后就直接打开了微信&#xff0c;并且进入了一个小程序。这种神奇的功能是如何实现的呢&#xff1f;本文将为你揭晓答案。 利用微信URL Link 接口生成链接 要实现短信中的链接直接打开…
阅读更多...
分位数回归模型及 Stata 具体操作步骤

分位数回归模型及 Stata 具体操作步骤

目录 一、引言 二、理论原理 三、数据 四、Stata 程序代码及解释 五、代码运行结果及分析 一、引言 分位数回归作为一种强大的统计分析方法&#xff0c;能够更全面地揭示自变量与因变量在不同分位数水平上的关系。与传统回归仅关注均值不同&#xff0c;分位数回归有助于我们…
阅读更多...
function-calling初体验

function-calling初体验

课程地址&#xff1a;https://learn.deeplearning.ai/courses/function-calling-and-data-extraction-with-llms/lesson/1/introduction github notebook地址&#xff1a;https://github.com/kingglory/LLMs-function-calling/tree/main Function-Calling 介绍 函数调用(Funct…
阅读更多...
GAMES104：04游戏引擎中的渲染系统1：游戏渲染基础-学习笔记

GAMES104：04游戏引擎中的渲染系统1：游戏渲染基础-学习笔记

文章目录 概览&#xff1a;游戏引擎中的渲染系统四个课时概览 一&#xff0c;渲染管线流程二&#xff0c;了解GPUSIMD 和 SIMTGPU 架构CPU到GPU的数据传输GPU性能限制 三&#xff0c;可见性Renderable可渲染对象提高渲染效率Visibility Culling 可见性裁剪 四&#xff0c;纹理压…
阅读更多...
格式化选NTFS还是exFAT 格式化NTFS后Mac不能用怎么办 移动硬盘格式化ntfs和exfat的区别

格式化选NTFS还是exFAT 格式化NTFS后Mac不能用怎么办 移动硬盘格式化ntfs和exfat的区别

面对硬盘、U盘或移动硬盘的格式化决策&#xff0c;NTFS与exFAT作为主流的文件系统&#xff0c;用户在选择时可以根据它们的不同特点来选择适用场景。下面我们来看看格式化选NTFS还是exFAT&#xff0c;格式化NTFS后Mac不能用怎么办的相关内容。 一、格式化选NTFS还是exFAT 在数…
阅读更多...
网络基础：EIGRP

网络基础：EIGRP

EIGRP&#xff08;Enhanced Interior Gateway Routing Protocol&#xff09;是由思科开发的一种高级距离矢量路由协议&#xff0c;结合了距离矢量和链路状态路由协议的优点&#xff1b;EIGRP具有快速收敛、高效带宽利用、负载均衡等特点&#xff0c;适用于各种规模的网络。EIGR…
阅读更多...
面试题springboot面试

面试题springboot面试

文章目录 Spring的依赖注入构造器注入stetter注入属性注入 springboot的优势第一开箱即用约定大于配置内嵌tomcat服务器 javaweb的三大组件springboot的自动配置原理SpringIoc的实现机制springmvcspring如何简化开发 Spring的依赖注入 构造器注入 stetter注入 属性注入 使用…
阅读更多...
python小练习04

python小练习04

三国演义词频统计与词云图绘制 import jieba import wordcloud def analysis():txt open("三国演义.txt",r,encodingutf-8).read()words jieba.lcut(txt)#精确模式counts {}for word in words:if len(word) 1:continueelif word "诸葛亮" or word &q…
阅读更多...
环保管理新篇章：智慧环保引领制造业走向绿色未来

环保管理新篇章：智慧环保引领制造业走向绿色未来

环保领域作为当代社会焦点之一&#xff0c;其重要性不言而喻&#xff0c;直接关系到人类生存环境的可持续发展&#xff0c;因此吸引了政府、企业及社会各界的深切关注。然而&#xff0c;在环保行业蓬勃发展的背后&#xff0c;亦浮现出一系列亟待解决的痛点&#xff1a;融资渠道…
阅读更多...
PyTorch MNIST手写体识别：SwanLab可视化训练

PyTorch MNIST手写体识别：SwanLab可视化训练

MNIST手写体识别是深度学习、CV的“Hello World”&#xff0c;无数人从这个任务入门&#xff0c;进入深度学习的世界&#xff5e; 进阶请看&#xff1a;PyTorch猫狗分类 这篇文章我将带大家使用SwanLab&#xff08;训练可视化&#xff09;、PyTorch&#xff08;深度学习框架&…
阅读更多...
Hive常用的内置函数

Hive常用的内置函数

文章目录 聚合类1.指定列值的数目2.指定列值求和3.最大值4.最小值5.平均值6.中位数函数7.分位数函数 数值类1.取整函数Round(a)2.指定精度取整ROUND(double a,int b)3.向上取整FLOOR()4.向下取整CEIL()5.随机数 rand()6.绝对值函数 日期类获取当前日期获取当前时间戳日期前后日…
阅读更多...
【Java环境配置过程详解（包括IDEA配置Java）】

【Java环境配置过程详解（包括IDEA配置Java）】

目录 一、JDK下载安装 1. 官网下载JDK 2. 本地安装JDK 3. 配置环境变量 4. 验证是否安装成功 ​编辑二、IDEA进行安装下载 1. 官网下载 IDEA 2、IDEA进行Java开发 1. 创建Java项目 2. 程序测试 一、JDK下载安装 1. 官网下载JDK 1&#xff09;官网链接: https://www.o…
阅读更多...
IT行业入门，如何假期逆袭，实现抢跑

IT行业入门，如何假期逆袭，实现抢跑

目录 前言 1.IT行业领域分类 2.基础课程预习指南 3.技术学习路线 4.学习资源推荐 结束语 前言 IT&#xff08;信息技术&#xff09;行业是一个非常广泛和多样化的领域&#xff0c;它包括了许多不同的专业领域和职业路径。如果要进军IT行业&#xff0c;我们应该要明确自己…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023