设计模式-组合模式(整体-部分模式)

组合模式(整体-部分模式)

组合模式介绍

定义

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

优点

• [透明组合模式]用户可以一致的处理单个对象和组合对象，不需要辨别是树枝还是树叶，非常便利
• 可以任意组合，无限嵌套组件，组合成用户需要的组件！
• 符合开闭原则，便于添加新的组件

应用场景

• 在需要表示一个对象整体与部分层次结构的场合
• 需要对用户隐藏组合对象与单个对象的不同，用户可以使用[透明组合模式]统一的接口应对所有对象场合。

组合模式结构与实现

结构

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

透明组合模式

树叶与树枝实现同一个接口，用户对树叶的感知是透明的！树叶也需要实现树枝的add()等方法。

结构图

模板实现

import java.util.ArrayList;

/**
 * 抽象构件
 */
interface Component {
    /**
     * 添加子构件
     * @param c 需要添加的子构件
     */
    public void add(Component c);

    /**
     * 移除子构件
     * @param c 需要移除的子构件
     */
    public void remove(Component c);

    /**
     * 获取子构件
     * @param i 需要获取的子构件下标
     * @return  根据 指定下标 获取的子构件
     */
    public Component getChild(int i);

    /**
     * 构件操作
     */
    public void operation();
}

/**
 * 树叶构件
 */
class Leaf implements Component {
    private String name;

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

    public String getName() {
        return name;
    }

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

    @Override
    public void add(Component c) {
        System.out.println("叶子构件无法添加子构件！");
    }
    @Override
    public void remove(Component c) {
        System.out.println("叶子构件无子构件！");
    }
    @Override
    public Component getChild(int i) {
        System.out.println("叶子构件无子构件！");
        return null;
    }
    @Override
    public void operation() {
        System.out.println("树叶" + name + ":被访问！");
    }
}

/**
 * 树枝构件
 */
class Composite implements Component {
    private final ArrayList<Component> children = new ArrayList<>();

    @Override
    public void add(Component c) {
        children.add(c);
    }
    @Override
    public void remove(Component c) {
        children.remove(c);
    }
    @Override
    public Component getChild(int i) {
        return children.get(i);
    }
    @Override
    public void operation() {
        for (Component obj : children) {
            obj.operation();
        }
    }
}

public class TransparentTemplateClient {
    public static void main(String[] args) {
        Component c0 = new Composite();
        Component c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();

        System.out.println("--------------");

        // 尝试给叶子构件添加子构件！
        leaf1.add(leaf2);
    }
}

运行结果：

树叶1:被访问！
树叶2:被访问！
树叶3:被访问！
--------------
叶子构件无法添加子构件！

安全组合模式

树叶和树枝分别实现自不同接口，用户需要了解哪些是树叶哪些是树枝。但是树叶无需实现无用方法，保证系统安全性。

结构图

咱们为了更好的区分，可以给叶子构件与树枝构件分别创建一个接口(继承自Component)

模板实现

import java.util.ArrayList;

/**
 * 顶层抽象构建
 */
interface Component {
    /**
     * 构件操作
     */
    void operation();
}

/**
 * 抽象构件:树枝
 */
interface Composite extends Component {
    /**
     * 添加子构件
     * @param c 需要添加的子构件
     */
    void add(Component c);

    /**
     * 移除子构件
     * @param c 需要移除的子构件
     */
    void remove(Component c);

    /**
     * 获取子构件
     * @param i 需要获取的子构件下标
     * @return  根据 指定下标 获取的子构件
     */
    Component getChild(int i);
}
/**
 * 抽象构件:树叶
 */
interface Leaf extends Component {
    /**
     * 获取树叶名称
     * @return  树叶名称
     */
    String getName();

    /**
     * 设置树叶名称
     * @param name  设置的树叶名称
     */
    void setName(String name);
    /**
     * 构件操作
     */
    @Override
    void operation();
}

/**
 * 树叶构件
 */
class LeafConcrete implements Leaf {
    private String name;

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

    @Override
    public String getName() {
        return name;
    }

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

    @Override
    public void operation() {
        System.out.println("树叶[" + name + "]被访问！");
    }
}

/**
 * 树枝构件
 */
class CompositeConcrete implements Composite {
    private final ArrayList<Component> children = new ArrayList<>();

    @Override
    public void add(Component c) {
        children.add(c);
    }
    @Override
    public void remove(Component c) {
        children.remove(c);
    }
    @Override
    public Component getChild(int i) {
        return children.get(i);
    }
    @Override
    public void operation() {
        for (Component obj : children) {
            obj.operation();
        }
    }
}

public class SafeTemplateClient {
    public static void main(String[] args) {
        Composite c0 = new CompositeConcrete();
        Composite c1 = new CompositeConcrete();
        Leaf leaf1 = new LeafConcrete("1");
        Leaf leaf2 = new LeafConcrete("2");
        Leaf leaf3 = new LeafConcrete("3");
        // c0树枝添加 leaf1叶子 和 c1树枝
        c0.add(leaf1);
        c0.add(c1);
        // c1树枝添加 leaf2 和 leaf3 树叶
        c1.add(leaf2);
        c1.add(leaf3);
        // 访问c0树枝上所有叶子节点
        c0.operation();
        System.out.println("----------------");
        //通过c0树枝获取c1树枝并删除c1树枝上的leaf3叶子
        ((Composite)c0.getChild(1)).remove(leaf3);
        //再次访问c0树枝上所有叶子节点
        c0.operation();
    }
}

运行结果

树叶[1]被访问！
树叶[2]被访问！
树叶[3]被访问！
----------------
树叶[1]被访问！
树叶[2]被访问！