组合模式.

定义

将对象组合成树状的层次结构，用来表示“整体-部分”的关系 使用户对单个对象和组合对象具有一致性

根节点–树枝节点–叶子节点
根节点和树枝节点的本质是一种数据类型，可以作为容器使用，叶子节点和树枝节点不属于一种类型；组合模式中将树枝节点和叶子节点看作是同一种数据类型（用统一接口定义）让他们具有一致行为

架构

抽象组件角色、树叶组件角色、、树枝组件角色/中间组件

两种实现模式

透明式：
抽象组件声明了所有子类中的全部方法，客户端无需区别树枝对象和叶子对象，对客户端来说是透明的，树叶组件没有添加、移除、和获取子节点方法，要实现他们会带来安全问题；
安全式：
管理子组件的方法移到树枝组件中，抽象组件和树叶组件没有对子类对象管理的方法，由于叶子和分支有不同的接口，客户端在调用的时候要知道树叶对象和树枝对象的存在，失去了透明性；

代码

透明模式（lucency）

Composite

/**
 *
 * Description:
 *      树枝
 * @author: mushi
 * @Date: 2021/2/20 9:50
 */
public class Composite implements Root{

    private List<Root> children = new ArrayList<>();

    /**添加子节点，添加树叶*/
    @Override
    public void add(Root c) {
        children.add(c);
    }

    /**移除子节点，移除树叶*/
    @Override
    public void remove(Root c) {
        children.remove(c);
    }

    /**获取子节点*/
    @Override
    public Root getChild(int i) {
        return children.get(i);
    }

    /**访问子节点*/
    @Override
    public void operation() {
        for (Object o : children){
            ((Root)o).operation();
        }
    }

}

Leaf

/**
 *
 * Description:
 *      树叶
 * @author: mushi
 * @Date: 2021/2/20 9:51
 */
public class Leaf implements Root{

    private String name;

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

    @Override
    public void add(Root c) {

    }

    @Override
    public void remove(Root c) {

    }

    @Override
    public Root getChild(int i) {
        return null;
    }


    @Override
    public void operation() {
        System.out.println("透明模式树叶"+name);
    }

}

Root

/**树枝和树叶都要实现的接口*/
public interface Root {

    void add(Root c);
    void remove(Root c);
    Root getChild(int i);
    void operation();
}

Test

public class Test {

    public static void main(String[] args) {
        //树枝对象
        Root composite = new Composite();
        //树叶对象
        Root leaf01 = new Leaf("红");
        Root leaf02 = new Leaf("黄");
        Root leaf03 = new Leaf("绿");
        //添加树叶到树枝下
        composite.add(leaf01);
        composite.add(leaf02);
        composite.add(leaf03);
        //通过树枝访问树叶
        composite.operation();

    }

}

透明方式总结：
接口中声明了树枝类要实现的所有方法，因为树枝和树叶实现同一个接口，有些树枝需要的方法在树叶中不需要，则树叶类需要对不用实现的方法进行处理；因为树枝和树叶的职责并不完全相同，所以会导致树叶实现一些自身不需要的方法造成安全问题；

安全模式（safe）

Composite

/**
 *
 * Description:
 *          树枝
 * @author: mushi
 * @Date: 2021/2/20 10:06
 */
public class Composite implements Root{

    public List<Root> children = new ArrayList<>();

    /**添加子节点，添加树叶*/
    public void add(Root c) {
        children.add(c);
    }

    /**移除子节点，移除树叶*/
    public void remove(Root c) {
        children.remove(c);
    }

    /**获取子节点*/
    public Root getChild(int i) {
        return children.get(i);
    }

    /**访问子节点，访问树叶*/
    @Override
    public void operation() {
        for (Object o : children){
            ((Root)o).operation();
        }
    }

}

Leaf

/**
 *
 * Description:
 *
 * @author: mushi
 * @Date: 2021/2/20 10:07
 */
public class Leaf implements Root{

    private String name;

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

    @Override
    public void operation() {
        System.out.println("安全模式树叶"+name);
    }
}

Root

/**树枝树叶都要实现的接口*/
public interface Root {

    void operation();

}

Test

public class Test {

    public static void main(String[] args) {
        //树枝,和透明模式中的定义类型不一样，透明模式中用Root
        Composite composite = new Composite();
        //树叶
        Root leaf01 = new Leaf("黑");
        Root leaf02 = new Leaf("白");
        Root leaf03 = new Leaf("紫");
        //添加树叶到树枝下
        composite.add(leaf01);
        composite.add(leaf02);
        composite.add(leaf03);
        //通过树枝访问树叶
        composite.operation();
    }

}

安全模式总结：
接口中定义公共行为，树枝的增、删、获取子节点，都在自己类中单独封装
树叶中就不需要实现自身不需要的方法，提高了安全性
树枝和树叶内的方法就不一致了，在调用的时候就不能通过接口知道树枝和树叶有哪些行为了

总结

就是通过一个对象去操作多个对象中的方法，树叶全是长在树枝上，那么可以通过操作树枝来操作所有树叶。简单的说就是通过一个对象去批处理一堆对象中的方法。