GOF设计模式之组合设计模式(结构型模式) ✨ 每日积累

组合模式是什么

组合模式（Composite Pattern），又叫部分整体模式，作为结构型模式，组合模式是用于把一组相似的对象当作一个单一的对象。组合多个对象形成树形结构来表示“整体-部分”的关系层次，它创建了对象组的树形结构。

组合模式能干什么

它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。

使用场景

部分、整体场景，如树形菜单，文件、文件夹的管理。

组合模式优缺点

优点

1、高层模块调用简单：组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；

2、节点自由增加：更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，

缺点

1、在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

2、设计较复杂，客户端需要花更多时间理清类之间的层次关系；

3、不容易限制容器中的构件；

组合模式的结构

抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）
树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

辅助图示

树状辅助图

合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。

GOF设计模式之组合设计模式(结构型模式) ✨ 每日积累

示例代码图示

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。

GOF设计模式之组合设计模式(结构型模式) ✨ 每日积累

示例代码

1、抽象构件

public abstract class Component {
    abstract void add(Component c);
    abstract void remove(Component c);
    abstract Component getChild(int i);
    abstract int getNumber();
    abstract void operation();
}

2、容器节点

import java.util.ArrayList;

public class CompositeEmployee extends Component{
    private String name;
    private String dept;
    private String position;
    private int salary;
    private ArrayList<Component> componentArrayList;


    public CompositeEmployee(String name, String dept, String position, int salary) {
        this.name = name;
        this.dept = dept;
        this.position = position;
        this.salary = salary;
        this.componentArrayList = new ArrayList<>(16);
    }

    @Override
    void add(Component c) {
        if (!componentArrayList.contains(c)) componentArrayList.add(c);
    }

    @Override
    void remove(Component c) {
        if (componentArrayList.contains(c)) componentArrayList.remove(c);
    }

    @Override
    Component getChild(int i) {
        return componentArrayList.get(i) == null ? null : componentArrayList.get(i);
    }

    @Override
    int getNumber() {
        return componentArrayList.size();
    }

    /**
     * 在组合模式结构中，由于容器构件中仍然可以包含容器构件，
     * 因此在对容器构件进行处理时需要使用递归算法，
     * 即在容器构件的operation()方法中递归调用其成员构件的operation()方法。
     */
    @Override
    void operation() {
        if (position.equals("CEO")) this.salary += 2000;
        for (Object obj : componentArrayList) {
            Component component = (Component) obj;
            if(component instanceof CompositeEmployee) {
                ((CompositeEmployee) component).setSalary(((CompositeEmployee) component).getSalary() + 1000);
                ((Component) obj).operation();
            }else {
                ((LeafEmployee) component).setSalary(((LeafEmployee) component).getSalary() + 500);
            }
            //do somthin
        }
    }


    public String getName() {
        return name;
    }

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

    public String getDept() {
        return dept;
    }

    public void setDept(String dept) {
        this.dept = dept;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return ("[ 姓名 : "+ name
                +", 所属部门 : "+ dept + ", " +
                "职位 :"+ position + ", " +
                "薪水 :" + salary+" ]");
    }
}

3、叶子节点

import java.io.PrintStream;

public class LeafEmployee extends Component{
    private String name;
    private String dept;
    private String position;
    private int salary;

    public LeafEmployee(String name, String dept, String position, int salary) {
        this.name = name;
        this.dept = dept;
        this.position = position;
        this.salary = salary;
    }

    @Override
    void add(Component c) {
        //do somthing
    }

    @Override
    void remove(Component c) {
        //do somthing
    }

    @Override
    Component getChild(int i) {
        //do somthing
        return null;
    }

    @Override
    int getNumber() {
        //do somthing
        return 0;
    }

    @Override
    void operation() {
        //do somthing
        System.out.printf("我是员工 %d, 所属部门 %d, 薪水是 %d", name, dept, salary);
    }

    public String getName() {
        return name;
    }

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

    public String getDept() {
        return dept;
    }

    public void setDept(String dept) {
        this.dept = dept;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return (" [ 姓名 : "+ name
                +", 所属部门 : "+ dept + ", " +
                "职位 :"+ position + ", " +
                "薪水 :" + salary+" ]");
    }
}

4、Client

public class TestClient {
    public static void main(String[] args) {
        //定义CEO
        Component componentCEO =
                new CompositeEmployee("John", "", "CEO", 40000);
        //定义TeamLeader
        Component componentTeamLealderOfJavaBackend =
                new CompositeEmployee("Robert", "JavaBackend", "TL", 25000);
        Component componentTeamLealderOfFrontEnd =
                new CompositeEmployee("Michel", "FrontEnd", "TL",25000);
        //定义普通员工
        Component componentFrontEndEmployee1 = new LeafEmployee("Bob", "FrontEnd", "Employee", 8000);
        Component componentFrontEndEmployee2 = new LeafEmployee("Laura", "FrontEnd",  "Employee",9000);

        Component componentJavaBackend1 = new LeafEmployee("Richard", "JavaBackend",  "Employee",9000);
        Component componentJavaBackend2 = new LeafEmployee("Rob", "JavaBackend",  "Employee",9000);

        //对员工进行装载
        componentCEO.add(componentTeamLealderOfJavaBackend);
        componentCEO.add(componentTeamLealderOfFrontEnd);

        componentTeamLealderOfJavaBackend.add(componentJavaBackend1);
        componentTeamLealderOfJavaBackend.add(componentJavaBackend2);

        componentTeamLealderOfFrontEnd.add(componentFrontEndEmployee1);
        componentTeamLealderOfFrontEnd.add(componentFrontEndEmployee2);



        //打印所有员工
        System.out.println(componentCEO);
        for (int i = 0; i < componentCEO.getNumber(); i++) {
            System.out.println(componentCEO.getChild(i));
            for (int i1 = 0; i1 < componentCEO.getChild(i).getNumber(); i1++) {
                System.out.println(componentCEO.getChild(i).getChild(i1));
            }
        }

        System.out.println("----------------------------------------------");
        componentCEO.operation();
        //为所有员工调薪一次
        System.out.println(componentCEO);
        for (int i = 0; i < componentCEO.getNumber(); i++) {
            System.out.println(componentCEO.getChild(i));
            for (int i1 = 0; i1 < componentCEO.getChild(i).getNumber(); i1++) {
                System.out.println(componentCEO.getChild(i).getChild(i1));
            }
        }
    }
}

运行结果

[ 姓名 : John, 所属部门 : , 职位 :CEO, 薪水 :40000 ]
[ 姓名 : Robert, 所属部门 : JavaBackend, 职位 :TL, 薪水 :25000 ]
 [ 姓名 : Richard, 所属部门 : JavaBackend, 职位 :Employee, 薪水 :9000 ]
 [ 姓名 : Rob, 所属部门 : JavaBackend, 职位 :Employee, 薪水 :9000 ]
[ 姓名 : Michel, 所属部门 : FrontEnd, 职位 :TL, 薪水 :25000 ]
 [ 姓名 : Bob, 所属部门 : FrontEnd, 职位 :Employee, 薪水 :8000 ]
 [ 姓名 : Laura, 所属部门 : FrontEnd, 职位 :Employee, 薪水 :9000 ]
----------------------------------------------
[ 姓名 : John, 所属部门 : , 职位 :CEO, 薪水 :42000 ]
[ 姓名 : Robert, 所属部门 : JavaBackend, 职位 :TL, 薪水 :26000 ]
 [ 姓名 : Richard, 所属部门 : JavaBackend, 职位 :Employee, 薪水 :9500 ]
 [ 姓名 : Rob, 所属部门 : JavaBackend, 职位 :Employee, 薪水 :9500 ]
[ 姓名 : Michel, 所属部门 : FrontEnd, 职位 :TL, 薪水 :26000 ]
 [ 姓名 : Bob, 所属部门 : FrontEnd, 职位 :Employee, 薪水 :8500 ]
 [ 姓名 : Laura, 所属部门 : FrontEnd, 职位 :Employee, 薪水 :9500 ]

GOF设计模式之组合设计模式(结构型模式) ✨ 每日积累

组合模式是什么

组合模式能干什么

使用场景

组合模式优缺点

优点

缺点

组合模式的结构

辅助图示

树状辅助图

示例代码图示

示例代码

1、抽象构件

2、容器节点

3、叶子节点

4、Client

运行结果

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method