设计模式之组合模式

每日一个设计模式，今日我们学习的是组合模式。

组合模式

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

组合模式结构图

下面编写代码

组合中的对象声明接口

public abstract class Component {

    protected String name;
    

    //增加树叶或树枝的功能
    public abstract void add(Component component);
    //移除树叶或树枝的功能
    public abstract void remove(Component component);
    //具体方法,显示名称和级别
    public abstract void display(int depth);

    public String getName() {
        return name;
    }

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

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

叶子节点

//叶子节点
public class Leaf extends Component{

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

    @Override
    public void add(Component component) {
        System.out.println("Cannot add to a leaf!");
    }
    //用于叶子节点不能再增加树枝和树叶,所以在这里给个默认的实现,这样做可以消除叶子节点
    //和枝节点对象在抽象层次的区分,它们具备完全一致的接口
    @Override
    public void remove(Component component) {
        System.out.println("Cannot remove to a leaf!");
    }
    //叶子节点的具体方法,此处是显示其名称和级别
    @Override
    public void display(int depth) {
        System.out.println(StrUtil.fillAfter("", '-', depth)+name);
    }

}

有枝节点，用来存储子节点，实现了add和remove功能

public class Composite extends Component{

    List<Component> children = new LinkedList<>();


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

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

    @Override
    public void remove(Component component) {
        children.remove(component);
    }
    //显示其枝节点名称,并对其下级进行遍历
    @Override
    public void display(int depth) {
        System.out.println(StrUtil.fillAfter("",'-',depth)+name);
        children.forEach(item->{
            item.display(depth+2);
        });
    }
}

客户端

public class Client {

    public static void main(String[] args) {
        Composite composite = new Composite("root");
        composite.add(new Leaf("Leaf A"));
        composite.add(new Leaf("Leaf B"));

        Composite composite1 = new Composite("Composite X");
        composite1.add(new Leaf("leaf xa"));
        composite1.add(new Leaf("leaf xb"));

        composite.add(composite1);

        Composite composite2 = new Composite("Composite XY");
        composite2.add(new Leaf("leaf XYA"));
        composite2.add(new Leaf("leaf XYB"));

        composite1.add(composite2);

        composite.add(new Leaf("leaf c"));

        Leaf leaf = new Leaf("leaf d");
        composite.add(leaf);
        composite.remove(leaf);

        composite.display(1);

    }

输出：

-root
---Leaf A
---Leaf B
---Composite X
-----leaf xa
-----leaf xb
-----Composite XY
-------leaf XYA
-------leaf XYB
---leaf c

透明方式和安全方式

树可能有无数个分支，但是反复使用Composite就可以实现树状结构了。可能大家会有疑问，为什么Leaf类中也要有add和remove的实现，树叶不是不可再增长分支吗？

这种方式就叫做透明方式。

透明方式：在Component中声明所有用来管理子对象的方法，其中包括add、remove等，这样实现Component接口的所有子类都具备了add、remove功能。这样做的好处就是叶子节点和枝节点对于外界没有任何区别，它们具备完全一致的行为接口。但问题也很明显，因为Leaf类本身不具备add()、remove()方法的功能，所有实现它是没有意义的。

安全方式：在Component类中不去声明add和remove方法，那么子类Leaf也不需要去实现它，而是在Composite声明所有用来管理子类对象的方法，但是由于不够透明，树叶和树枝将不具有相同的接口，客户端调用需要做相应判断，带来了不便，

组合模式介绍

组合模式定义了包含基本对象、组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象。而这个组合对象又可以被组合，这样不断的递归下去，客户代码中，任何用到基本对象的地方都可以使用组合对象了。用户无需关心到底是处理一个叶节点还是处理一个组合对象，也就用不着为定义组合而写一些选择判断语句了。

组合模式使用场景

需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一的使用组合结构中的所有对象时，就该考虑使用组合模式了。

最后一句话总结：组合模式让客户可以一致地使用组合结构和单个对象。