笨蛋学设计模式结构型模式-组合模式【12】-Toy模板网

这篇具有很好参考价值的文章主要介绍了笨蛋学设计模式结构型模式-组合模式【12】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

7.6组合模式

7.6.1概念

组合模式通过将对象组合成树状结构来表示 部分-整体的层次关系，从而让客户端能够以同样的方式处理单个对象和对象组合，在使用中将他们视为同一类型的对象。

7.6.2场景

在文件系统中，比如目录和文件就形成了一个树形结构，目录可以包含文件以及子目录，而子目录同样的也可以包含文件以及子目录的子目录。

7.6.3优势 / 劣势

一致性：客户端可以统一的处理单个对象和对象的组合，简化了客户端的代码
动态性：组合模式支持动态地添加或删除子对象，使得树形结构的构建更加灵活

复杂性：由于树形机构的嵌套特性，可能会增加代码的复杂性
深度限制：若组合模式的树形结构的深度过大，可能会导致性能问题

7.6.4组合模式可分为

组件Component：组合模式的根节点，定义组合中所有对象的通用接口，可以是抽象类或接口。该类中定义了子类的共性内容
叶子Leaf：实现了Component接口的叶子节点，表示组合中的叶子对象，叶子节点没有子节点
合成Composite：作用是存储子部件，并且在Composite中实现了对子部件的相关操作，比如添加、删除、获取子组件等

7.6.5组合模式

package com.technologystatck.designpattern.mode.combination;

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

public class Combination {
    public static void main(String[] args) {
        //创建叶子节点
        Leaf leaf = new Leaf();

        //创建组合节点，并添加叶子节点
        Composite composite = new Composite();
        composite.add(leaf);

        //统一调用
        composite.operation();

        System.out.println("----------------------");
        composite.remove(leaf);
        composite.operation();
    }
}

//组件接口
interface Component{
    void operation();
}

//叶子节点
class Leaf implements Component{

    @Override
    public void operation() {
        System.out.println("Leaf operation");
    }
}

//组合节点
class Composite implements Component{
    private List<Component> components=new ArrayList<>();

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

    public void remove(Component component){
        components.remove(component);
    }

    @Override
    public void operation() {
        System.out.println("Composite operation");
        for(Component component:components){
            component.operation();
        }
    }
}

7.6.6实战

7.6.6.1题目描述

小明所在的公司内部有多个部门，每个部门下可能有不同的子部门或者员工。

请你设计一个组合模式来管理这些部门和员工，实现对公司组织结构的统一操作。部门和员工都具有一个通用的接口，可以获取他们的名称以及展示公司组织结构。

7.6.6.2输入描述

第一行是一个整数 N（1 <= N <= 100），表示后面有 N 行输入。

接下来的 N 行，每行描述一个部门或员工的信息。部门的信息格式为 D 部门名称，员工的信息格式为 E 员工名称，其中 D 或 E 表示部门或员工。

7.6.6.3输出描述

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

7.6.6.4代码

package com.technologystatck.designpattern.mode.combination;

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

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //先读取公司名称
        String companyName = scanner.nextLine();

        //创建公司对象，并设置公司名称，并将公司添加到树枝节点中
        Company company = new Company(companyName);


        //读取部门和员工信息
        int nums = scanner.nextInt();
        scanner.nextLine();
        for(int i=0;i<nums;i++){
            String type = scanner.next();
            //获取名字并去除空格，以便后续添加到组合节点中
            String name = scanner.nextLine().trim();

            if("D".equals(type)){
                //创建部门对象，并添加到组合节点中
                company.add(new Department(name));
            }else if("E".equals(type)){
                //创建员工对象，并添加到组合节点中
                company.add(new Employee(name));
            }
        }
        //显示公司信息
        company.display();

    }
}

//组件接口
interface Components{
    void display(int depth);
}

//部门的叶子节点
class Department implements Components{

    //部门名称
    private String name;
    //部门下的员工
    private List<Components> children;

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

    //添加员工
    public void add(Components component){
        children.add(component);
    }
    //删除员工
    public void remove(Components component){
        children.remove(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 (Components components : children) {
            components.display(depth+1);
        }
    }
}

//员工的叶子节点
class Employee implements Components{
    //员工名
    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);
    }
}

//树枝节点，也就是组合节点
class Company{
    private String name;
    //部门相当于根节点
    private Department root;

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

    public void add(Components components){
        root.add(components);
    }
    public void remove(Components components){
        root.remove(components);
    }

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

7.6.7总结

组合模式
优点：可以通过组合多个对象形成对象组合，然后再增加新的功能或行为，只需要对组合对象进行操作
总结：是一种通过将对象组合成树形结构，提供了灵活且统一的方式来处理单个对象和对象组合
场景：需要构建具有部分-整体层次结构的场景，比如组织架构管理、文件系统的文件和文件夹组织文章来源地址https://www.toymoban.com/news/detail-800290.html