对组合模式的理解

目录

  • 一、场景
    • 1、题目描述 【[案例来源](https://kamacoder.com/problempage.php?pid=1090)】
    • 2、输入描述
    • 3、输出描述
    • 4、输入示例
    • 5、输出示例
  • 二、实现（假的组合模式）
    • 1、代码
    • 2、为什么上面的写法是假的组合模式？
  • 三、实现（真的组合模式）
    • 1、案例来源的实现
    • 2、我的实现
  • 四、个人思考

一、场景

设计模式很依赖场景，通过场景也能更好理解这种模式解决了什么问题。

  • 无论是学校还是公司，都存在组织结构。而且，这种结构多半是树状结构。
  • 当类与类之间的结构也需要表达成树状结构时，组合模式就来大显身手了。

1、题目描述 【案例来源】

小明所在的公司内部有多个部门，每个部门下可能有不同的子部门或者员工。
请你设计一个组合模式来管理这些部门和员工，实现对公司组织结构的统一操作。部门和员工都具有一个通用的接口，可以获取他们的名称以及展示公司组织结构。

2、输入描述

第一行是一个整数 N（1 <= N <= 100），表示后面有 N 行输入。
接下来的 N 行，每行描述一个部门或员工的信息。部门的信息格式为 D 部门名称，员工的信息格式为 E 员工名称，其中 D 或 E 表示部门或员工。

3、输出描述

输出公司的组织结构，展示每个部门下的子部门和员工

4、输入示例

MyCompany
8
D HR
E HRManager
D Finance
E AccountantA
E AccountantB
D IT
E DeveloperA
E DeveloperB

5、输出示例

Company Structure:
MyCompany
HR
HRManager
Finance
AccountantA
AccountantB
IT
DeveloperA
DeveloperB

二、实现（假的组合模式）

1、代码

public interface Component {
    String showName();
}

public class Company implements Component {
    private final String name;

    @Setter
    private List<Department> departments;

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

    public void addDepartment(Department department) {
        if (CollectionUtils.isEmpty(departments)) {
            departments = new ArrayList<>();
            departments.add(department);

        } else {
            departments.add(department);
        }
    }

    @Nullable
    public Department gotLastDepartment() {
        if (CollectionUtils.isEmpty(departments)) {
            return null;
        } else {
            return departments.get(departments.size() - 1);
        }
    }

    @Override
    public String showName() {
        return name;
    }

    public String showCompanyStructure() {
        StringBuilder sb = new StringBuilder("Company Structure:\n").append(showName()).append("\n");

        Optional.ofNullable(departments).ifPresent(departments -> departments.stream().filter(Objects::nonNull).forEach(department -> {
            sb.append("  ").append(department.showName()).append("\n");
            Optional.ofNullable(department.getEmployees()).ifPresent(employees -> {
                employees.stream().forEach(
                        employee -> sb.append("    ").append(employee.showName()).append("\n")
                );
            });
        }));

        return sb.toString();
    }
}

@Data
public class Department implements Component {
    private String name;
    private List<Employee> employees;

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

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

    public void addEmployee(Employee employee) {
        if (CollectionUtils.isEmpty(employees)) {
            employees = new ArrayList<>();
            employees.add(employee);
        } else {
            employees.add(employee);
        }
    }
}

@AllArgsConstructor
public class Employee implements Component {
    private String name;

    @Override
    public String showName() {
        return name;
    }
}

public class Application {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String companyName = scanner.nextLine();
        Company company = new Company(companyName);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            String type = scanner.next();
            String name = scanner.next();

            if (StringUtils.equals(type, "D")) {
                company.addDepartment(new Department(name));
            } else if (StringUtils.equals(type, "E")) {
                Department department = company.gotLastDepartment();
                department.addEmployee(new Employee(name));
            }
        }
        System.out.printf(company.showCompanyStructure());
    }
}

2、为什么上面的写法是假的组合模式？

  • 场景中的公司结构：
    在这里插入图片描述
    • 对这个结构进行建模，不应该是：
public class Company implements Component {
    private final String name;

    @Setter
    private List<Department> departments;
}

public class Department implements Component {
    private String name;
    private List<Employee> employees;
}

public class Employee implements Component {
    private String name;
}
  • 因为上图实际上有2个基本结构：
// Company-Department (1 对 n)、Department-Employee（1对n）
class Composite implements Component {
	private String name;
	private List<Component> children;
}

// 这个便是Employee
class Leaf implements Component {
	private String name;
}
  • 所以，没有Get到这一点，就容易写出假的组合模式。（写的时候也会发现写的很累）

三、实现（真的组合模式）

1、案例来源的实现

  • 场景中题目的提供方，也给出了相应的实现：
public interface Component {
    void display(int depth);
}

public class Department implements Component {
    private String name;
    private List<Component> children;

    public Department(String name) {
        this.name = name;
        this.children = new ArrayList<>();
    }

    public void add(Component component) {
        children.add(component);
    }

    @Override
    public void display(int depth) {
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            indent.append("  ");
        }

        System.out.println(indent + name);
        for (Component component : children) {
            component.display(depth + 1);
        }
    }
}

public class Employee implements Component {
    private String name;

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

    @Override
    public void display(int depth) {
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            indent.append("  ");
        }
        System.out.println(indent + "  " + name);
    }
}

public class Company {
    private String name;
    private Department root;

    public Company(String name) {
        this.name = name;
        this.root = new Department(name);
    }

    public void add(Component component) {
        root.add(component);
    }

    public void display() {
        System.out.println("Company Structure:");
        root.display(0); // 从 1 开始，以适配指定的缩进格式
    }


public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
// 读取公司名称
        String companyName = scanner.nextLine();
        Company company = new Company(companyName);
// 读取部⻔和员工数量
        int n = scanner.nextInt();
        scanner.nextLine(); // 消耗换行符
// 读取部⻔和员工信息
        for (int i = 0; i < n; i++) {
            String type = scanner.next();
            String name = scanner.nextLine().trim();
            if ("D".equals(type)) {

                Department department = new Department(name);
                company.add(department);
            } else if ("E".equals(type)) {
                Employee employee = new Employee(name);
                company.add(employee);
            }
        }
// 输出公司组织结构
        company.display();
    }
}
  • debug会发现，这并没有正确表示company的结构：
    在这里插入图片描述
  • 那为啥能输出这样的结果呢？
MyCompany
  HR
    HRManager
  Finance
    AccountantA
    AccountantB
  IT
    DeveloperA
    DeveloperB
  • 原因在于：
public class Employee implements Component {
    ...

    @Override
    public void display(int depth) {
        StringBuilder indent = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            indent.append("  ");
        }
        System.out.println(indent + "  " + name); // 这里的depth实际上是1，因此作者多加了"  "
    }
}

显然，这并不是正确的实现。

2、我的实现

public interface Component {
    void showName(int depth);
}

public class Composite implements Component {
    private String name;
    private List<Component> children;

    public Composite(String name) {
        this.name = name;
        children = new ArrayList<>();
    }

    public void addComponent(Component component) {
        children.add(component);
    }

    public Composite gotLastComposite() {
        if (!children.isEmpty()) {
            Component component = children.get(children.size() - 1);
            if (component instanceof Composite) {
                return (Composite) component;
            } else {
                throw new RuntimeException("last component is not composite");
            }

        } else {
            throw new RuntimeException("doesn't exist last component");
        }
    }

    @Override
    public void showName(int depth) {
        System.out.println(StringUtils.repeat("  ", depth) + name);
        for (Component child : children) {
            child.showName(depth + 1);
        }
    }
}

@AllArgsConstructor
public class Employee implements Component {
    private String name;

    @Override
    public void showName(int depth) {
        System.out.println(StringUtils.repeat("  ", depth) + name);
    }
}

public class Company extends Composite {

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

    @Override
    public void showName(int depth) {
        System.out.println("Company Structure:");
        super.showName(depth);
    }
}

public class Application {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String companyName = scanner.nextLine();
        Company company = new Company(companyName);

        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            String type = scanner.next();
            String name = scanner.next();

            if (StringUtils.equals(type, "D")) {
                company.addComponent(new Composite(name));
            } else if (StringUtils.equals(type, "E")) {
                Composite department = company.gotLastComposite();
                department.addComponent(new Employee(name));
            }
        }

        company.showName(0);
    }
}
  • Company的结构：
    在这里插入图片描述

四、个人思考

  • 对真实场景建模后，类呈现树状结构，那么可以尝试使用组合模式设计代码：
class Composite implements Component {
	private String name;
	private List<Component> children;
}

// 这个便是Employee
class Leaf implements Component {
	private String name;
}

组合模式：实现接口A + 组合多个接口A

  • 装饰模式、桥接模式都用到了组合的理念，但都是一对一的形式：
  • 装饰模式：实现接口A + 组合接口A
public class EncryptDataSourceImpl implements DataSource {
    private DataSource dataSource;
}
  • 桥接模式：实现接口A + 组合接口B
public class Circle implements Shape {
    private Color color;
}

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

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

相关文章

初识C++·类和对象(中)(3)

初识C++·类和对象(中)(3)

前言&#xff0c;最难的已经结束了&#xff0c;来点轻松了放松一下。 目录 1 流重载 2 const成员 3 取地址及const取地址操作符重载 1 流重载 C语言中printf和scanf是有局限性&#xff0c;只能直接打印内置类型&#xff0c;对于自定义类型就哦豁了&#xff0c;所以在C中就…
阅读更多...
38. UE5 RPG 修改火球术的攻击方向以及按住Shift攻击

38. UE5 RPG 修改火球术的攻击方向以及按住Shift攻击

在前面&#xff0c;我们实现了火球术火球的制作&#xff0c;能够在释放火球术时&#xff0c;角色将播放释放技能动画&#xff0c;并实现了对火球的目标的服务器同步功能。 我们先回忆一下之前完成的内容。 在前面&#xff0c;我们先做了一个Actor&#xff0c;用于承载发射的火…
阅读更多...
java线程-线程池

java线程-线程池

简介 工作原理 如何获取线程池对象 构造器的参数含义 注意事项 构造器-ThreadPoolExecutor // ArrayBlockingQueue 是一个有界的阻塞队列&#xff0c;它的内部实现是一个数组。有界的意思是它的容量是有限的&#xff0c;我们必须在创建 ArrayBlockingQueue 实例的时候指定容量…
阅读更多...
01-服务与服务间的通信

01-服务与服务间的通信

这里是极简版&#xff0c;仅用作记录 概述 前端和后端可以使用axios等进行http请求 服务和服务之间也是可以进行http请求的spring封装的RestTemplate可以进行请求 用法 使用bean注解进行依赖注入 在需要的地方&#xff0c;自动注入RestTemplate进行服务和服务之间的通信 注…
阅读更多...
[2021最新]大数据平台CDH存储组件kudu之启用HA高可用(添加多个master)

[2021最新]大数据平台CDH存储组件kudu之启用HA高可用(添加多个master)

今天在做kudu高可用的时候没有参考官网&#xff0c;直接按照常规方式&#xff08;添加角色—>编辑属性—>启动&#xff09;结果发现报错&#xff1f;然后参考了一下文档之后发现这玩意儿还有点玄学&#xff0c;做一下记录。 1.添加两个master。kudu master有leader和foll…
阅读更多...
深入解析Tomcat的工作流程

深入解析Tomcat的工作流程

tomcat解析 Tomcat是一个广泛使用的开源Servlet容器&#xff0c;用于托管Java Web应用程序。理解Tomcat的工作流程对于开发人员和系统管理员来说是非常重要的。本文将深入探讨Tomcat的工作原理&#xff0c;包括请求处理、线程池管理、类加载、以及与Web服务器之间的通信。 ###…
阅读更多...
思颜肌密：匠心独蕴，传世掠影

思颜肌密：匠心独蕴，传世掠影

赋予延绵岁月以华彩乐章&#xff0c;将来自时间的承诺注入生活每分每秒&#xff0c;在思颜肌密的世界里&#xff0c;恒久之美并非遥不可及&#xff0c;它是艺术&#xff0c;亦是心意。华美节日翩然而至&#xff0c;思颜肌密拉开神秘帷幕&#xff0c;在惊鸿掠影中向世人展现传世…
阅读更多...
[数据结构与算法]-什么是二叉树？

[数据结构与算法]-什么是二叉树？

二叉树是一种数据结构&#xff0c;由节点组成&#xff0c;每个节点最多有两个子节点&#xff0c;分别称为左子节点和右子节点。二叉树的每个节点包含一个值&#xff0c;并且左子节点的值小于等于父节点的值&#xff0c;右子节点的值大于等于父节点的值。这个性质使得二叉树在搜…
阅读更多...
Linux系统维护:增加空闲内存的大小，以便进程有足够的基础内存(空闲内存)来运行

Linux系统维护:增加空闲内存的大小，以便进程有足够的基础内存(空闲内存)来运行

目录 一、问题 二、解决思路 &#xff08;一&#xff09;问题分析 &#xff08;二&#xff09;思路 1. 清理缓存 2. 结束不必要的进程 3. 优化应用程序和服务 4. 增加物理内存 5、注意事项 三、实际处理 &#xff08;一&#xff09;结束不必要的程序 &#xff08;二…
阅读更多...
批量规范化（batchnormalization）

批量规范化（batchnormalization）

ˆB 是小批量B的样本均值&#xff0c;σˆ B 是小批量B的样本标准差。应用标准化后&#xff0c;生成的小批量的平均 值为0和单位方差为1。由于单位方差&#xff08;与其他一些魔法数&#xff09;是一个主观的选择&#xff0c;因此我们通常包含 拉伸参数&#xff08;scale&#…
阅读更多...
vulfocus靶场之redis命令执行cve-2022-0543漏洞复现

vulfocus靶场之redis命令执行cve-2022-0543漏洞复现

漏洞&#xff1a; Redis是著名的开源Key-Value数据库&#xff0c;其具备在沙箱中执行Lua脚本的能力。 Debian以及Ubuntu发行版的源在打包Redis时&#xff0c;不慎在Lua沙箱中遗留了一个对象package&#xff0c;攻击者可以利用这个对象提供的方法加载动态链接库liblua里的函数&…
阅读更多...
初始化Git仓库时应该运行哪个命令？

初始化Git仓库时应该运行哪个命令？

文章目录 初始化Git仓库时&#xff0c;你应该运行git init这个命令。这个命令的作用是在你当前所在的目录里创建一个新的Git仓库。这样&#xff0c;你就可以在这个目录里开始使用Git来管理你的文件了。 下面我给你举个详细的例子来说明一下&#xff1a; 首先&#xff0c;你需要…
阅读更多...
网络原理-IP协议

网络原理-IP协议

一、IP协议报头 版本号:用来表示IP协议的版本,现在常用的IP协议有两个版本,IPv4和IPv6&#xff0c;其他版本可能只存在于实验室中&#xff0c;并没有被广泛的使用。 首部长度:用来表示IP报头的长度,因为存在"选项"字段&#xff0c;所以IP报头是可变长的,此处单位为4…
阅读更多...
春秋云镜 CVE-2023-51048

春秋云镜 CVE-2023-51048

靶标介绍&#xff1a; S-CMS v5.0 被发现存在SQLI。 开启靶场 根据题目查找S-CMS v5.0漏洞&#xff0c;百度没有查询到&#xff0c;使用必应搜索S-CMS v5.0 查找到githubCVE-2023-51052的描述 S-CMS v5.0 was discovered to contain a SQL injection... CVE-2023-51052 Git…
阅读更多...
Python程序设计 字典

Python程序设计 字典

教学案例十 字典 1. 判断出生地 sfz.txt文件中存储了地区编码和地区名称 身份证的前6位为地区编码&#xff0c;可以在sfz.txt文件中查询到地区编号对应的地区名称 编写程序&#xff0c;输入身份证号&#xff0c;查询并显示对应的地区名称 若该地区编码不在文件中&#xff0c;…
阅读更多...
11.事件处理

11.事件处理

事件处理 我们可以使用 v-on 指令 (简写为 ) 来监听 DOM 事件&#xff0c;并在事件触发时执行对应的 JavaScript。用法&#xff1a;v-on:click"methodName" 或 click"handler" 事件处理器的值可以是 内联事件处理器&#xff1a;事件被触发时执行的内联 J…
阅读更多...
不同版本vue安装vue-router

不同版本vue安装vue-router

vue-router 是vue官网发布的一个插件库&#xff0c;单页面路由。vue 和 vue-router 之间版本也需要对应。 vue2.x版本使用vue-router3.x版本&#xff0c;vue3.x使用vue-router4.x版本&#xff0c;根据自己的需要选择合适的版本 1、可以在安装前查看vue-router版本&#xff0c;…
阅读更多...
微信小程序开发笔记

微信小程序开发笔记

微信小程序开发笔记 1 微信小程序的项目结构 2 页面组成 一个微信小程序是由一个或多个页面组成的&#xff0c;这些页面被存放在pages目录中。下面以pages 目录下的index页面为例展示其组成部分&#xff0c;index页面的组成部分如下图所示。 由上图可知&#xff0c;index页面…
阅读更多...
Swift-20-基础数据类型

Swift-20-基础数据类型

数据定义 语法规则 先来看下下面的代码 import Cocoavar num1 "four" //a var num2: String "four" //b var num3 4 //c var num4: Int 4 //d上面的几行代码都能正常运行&#xff0c;其中a和b行等价&#xff0c;c和d行等价。区另就在于是否声…
阅读更多...
SpringBoot集成Sleuth

SpringBoot集成Sleuth

引入Maven依赖 <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-sleuth</artifactId></dependency> 配置yml文件 bootstrap.yml文件增加如下配置 注&#xff1a;这个配置不是必须要&#…
阅读更多...
最新文章

Copyright @ 2022~2023