设计模式-10-适配器模式-[组合模式]

1.[组合模式] 是 [对象的适配器模式] 的衍生模式

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

2.组合模式简介

       组合模式（又称“部分-整体”模式）是一种结构型设计模式。组合模式的思想是：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性（ 统计接口--不同实现 --- 对外表现一致[无差异调用] ）。

3.组合模式的三个角色

• 抽象组件（Component）：组合中所有具体组件的抽象接口，用于规范组件的属性和行为，相当于树的节点（Node）。
• 具体组件（Composite）：组合中每个具体的组件，相当于树的 枝节点 - 实现抽象接口。
• 未端具体组件（Leaf）：位于未端面的具体组件，没有子节点，相当于树的 叶子节点 - 实现抽象接口。

4.具体案例代码

       比如以下的商品类别树 

                               

 

抽象接口：抽象的组件对象，为组合中的对象声明接口，实现接口的缺省行为

/**
 * 抽象的组件对象，为组合中的对象声明接口，实现接口的缺省行为
 */
public abstract class A1_Component {

    // 子组件对象有的功能方法
    public abstract void operation(String preStr);

    public void addChild(A1_Component child) {
        // 缺省的实现-抛出异常 : 因为叶子对象没有这个功能，或子类未实现这个功能
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    public void removeChild(A1_Component child) {
        // 缺省的实现-抛出异常 : 因为叶子对象没有这个功能，或子类未实现这个功能
        throw new UnsupportedOperationException("对象不支持此功能");
    }

    public A1_Component getChildren(int index) {
        // 缺省的实现-抛出异常 : 因为叶子对象没有这个功能，或子类未实现这个功能
        throw new UnsupportedOperationException("对象不支持此功能");
    }
}

树干节点：组合类的定义

/**
 * 枝干节点 ： 组合类的定义
 */
public class A2_Composite extends A1_Component {

    /**
     * 组件的名字
     */
    private String name = "";

    /**
     * 用来存储组合对象中包含的子组件对象
     */
    private List<A1_Component> childComponents = null;

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

    /**
     * 向组合对象中添加组件对象
     */
    public void addChild(A1_Component child) {
        // 延迟初始化
        if (null == childComponents) {
            childComponents = new ArrayList<A1_Component>();
        }
        childComponents.add(child);
    }

    /**
     * 从组合对象中移除组件对象
     */
    public void removeChild(A1_Component child) {
        if (null != childComponents) {
            childComponents.remove(child);
        }
    }

    /**
     * 根据索引获取组合对象中对应的组件对象
     */
    public A1_Component getChildren(int index) {
        if (null != childComponents) {
            if (index >= 0 && index < childComponents.size()) {
                return childComponents.get(index);
            }
        }
        return null;
    }

    /**
     * 此处用于输出组件的树形结构，通常在里面需要实现递归的调用
     */
    @Override
    public void operation(String preStr) {
        // 先把自己输出
        System.out.println(preStr + "+" + name);
        // 如果还包含其他子组件，那么就输出这些子组件对象
        if (null != childComponents) {
            // 添加一个空格，表示向后缩进一个空格
            preStr += "   ";
            // 输出当前对象的子组件对象
            for (A1_Component component : childComponents) {
                // 递归地进行子组件相应方法的调用，输出每个子组件对象
                component.operation(preStr);
            }
        }
    }
}

叶子节点：

/**
 * 叶子节点
 */
public class A3_Leaf extends A1_Component {

    /**
     * 组件的名字
     */
    private String name = "";

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

    /**
     * 此处用于输出组件的树形结构
     * @param preStr
     */
    @Override
    public void operation(String preStr) {
        System.out.println(preStr + "-" + name);
    }
}

客户端调用：

/**
 * 客户端调用
 */
public class A4_Client {

    public static void main(String[] args) {
        // 定义多个Composite组合对象
        A1_Component root = new A2_Composite("服装");
        A1_Component c1 = new A2_Composite("男装");
        A1_Component c2 = new A2_Composite("女装");
        A1_Component c3 = new A2_Composite("母婴");

        // 定义多个Leaf叶子对象
        A1_Component leaf1 = new A3_Leaf("西服");
        A1_Component leaf2 = new A3_Leaf("夹克");
        A1_Component leaf3 = new A3_Leaf("衬衫");
        A1_Component leaf4 = new A3_Leaf("裙子");
        A1_Component leaf5 = new A3_Leaf("套装");
        A1_Component leaf6 = new A3_Leaf("鞋袜");
        A1_Component leaf7 = new A3_Leaf("孕妇装");
        A1_Component leaf8 = new A3_Leaf("婴儿装");

        // 组合成为树形的对象结构
        root.addChild(c1);
        root.addChild(c2);
        root.addChild(leaf6);
        c1.addChild(leaf1);
        c1.addChild(leaf2);
        c1.addChild(leaf3);
        c2.addChild(leaf4);
        c2.addChild(leaf5);
        c2.addChild(c3);
        c3.addChild(leaf7);
        c3.addChild(leaf8);

        // 调用根对象的输出功能输出整棵树
        root.operation("");
    }
}

调用结果：

+服装
   +男装
      -西服
      -夹克
      -衬衫
   +女装
      -裙子
      -套装
      +母婴
         -孕妇装
         -婴儿装
   -鞋袜

        组合模式解耦了客户程序与复杂元素内部结构，从而使客户程序可以像处理简单元素一样来处理复杂元素。

组合模式让你可以优化处理递归或分级数据结构。如果想要创建层次结构，并可以在其中以相同的方式对待所有元素，那么组合模式就是最理想的选择。

 

5.组合模式的使用场景

• 当想表达对象的部分-整体的层次结构时。
• 希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象时。

6.组合模式的优缺点

• 缺点：客户端需要花更多时间 理清类之间的层次关系
• 优点：无需关系处理的单个对象，还是组合的对象容器，实现容器之间的解耦合、当有新部件时容易添加进来。

 

 

本文地址：https://blog.csdn.net/ming1215919/article/details/107199846