组合模式(设计模式)

组合模式

什么是组合模式？

将对象组合成树形结构以表示部分-整体 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性

使用场景

需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一的使用组合对象时

抽象实现

三部分:一部分制定公共行为与管理子代接口，一部分是单体实现接口，一部分是组合体实现接口

/**
 * @author 州牧
 * @description 对象声明接口，定义对象的默认行为，声明一个接口用于访问和管理Component
 *
 * 为了可视化，增加一个depth变量展示叶子与树枝的长度
 * @since 2022-03-24 22:51
 */
public abstract class Component {

    protected String name;

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

    public abstract void add(Component component);
    public abstract void remove(Component component);
    public abstract void show(int depth);
}

/**
 * @author 州牧
 * @description 叶子节点对象，无子节点
 *
 * @since 2022-03-24 22:54
 */
public class Leaf extends Component{
    public Leaf(String name) {
        super(name);
    }

    @Override
    public void add(Component component) {
        System.out.println("叶子节点无此行为");
    }

    @Override
    public void remove(Component component) {
        System.out.println("叶子节点无此行为");
    }

    @Override
    public void show(int depth) {
        for (int i =0 ;i<=depth;i++){
            System.out.print("--");
        }
        System.out.println("叶子节点:"+name+"执行行为");

    }
}

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

/**
 * @author 州牧
 * @description 树枝节点，有子节点，可管理子节点
 * @since 2022-03-24 22:56
 */
public class Composite extends Component{

    private List<Component> children;

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

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

    @Override
    public void remove(Component component) {
        children.remove(component);
    }

    @Override
    public void show(int depth) {

        for (int i =0 ;i<=depth;i++){
            System.out.print("--");
        }
        System.out.println(name);
        for (Component child : children) {
            child.show(depth+2);
        }
    }
}

效果实现

/**
 * @author 州牧
 * @description 调用展示
 * @since 2022-03-24 23:00
 */
public class Client {
    public static void main(String[] args) {
        Composite root = new Composite("root");
        root.add(new Leaf("A"));
        root.add(new Leaf("B"));

        Composite c1 = new Composite("c1");
        c1.add(new Leaf("C"));
        c1.add(new Leaf("D"));

        root.add(c1);

        Composite c2 = new Composite("c2");
        c2.add(new Leaf("E"));
        c2.add(new Leaf("F"));

        c1.add(c2);

        root.show(0);

    }
}
/*
--root
------叶子节点:A执行行为
------叶子节点:B执行行为
------c1
----------叶子节点:C执行行为
----------叶子节点:D执行行为
----------c2
--------------叶子节点:E执行行为
--------------叶子节点:F执行行为

*/

通过观察我们发现叶子节点中关于管理子代对象的方法是无用的。由此介绍两个新概念，透明方式和组合方式。

透明方式

componet抽象类制定管理对象的方法，所有子代均实现。此做法导致叶子节点与树枝节点对于外界没有区别，外界调用无需做判断处理。上面的抽象实现就是透明方式。

安全模式

component抽象类不制定管理对象的方法，那么叶子节点则无需实现该方法，而树枝节点则额外声明管理的方法。这种做法导致，外界调用管理对象方法时需要做判断。

两种方式适用于不同的需求场景。