设计模式15-组合模式

一 组合模式的定义

         组合模式也叫合成模式，有时又叫部分-整体模式，主要是用来描述部分与整体的关系，定义：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用一致性。

       组合模式通用类图：

   Component抽象构建角色：定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性。

Leaf叶子构件：叶子对象，其下再也没有其他的分支，也就是遍历的最小单位。

Composite树枝构件：树枝对象，它的作用是组合树枝节点和叶节点形成一个树形结构。

下面来看看组合模式的通用源代码：

抽象构件：

package com.jack.component;

/**
 * Created by jack on 2018/1/26.
 * 抽象构件
 */
public abstract class Component {
    //个体和整体都具有的共享
    public void doSomething(){
        //编写业务逻辑
        System.out.println("abstract do something");
    }
}

   树枝构件：

package com.jack.component;

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

/**
 * Created by jack on 2018/1/26.
 */
public class Composite extends Component {
    //构建容器
    private List<Component> componentList = new ArrayList<>();

    /**
     * 增加一个叶子构件或者树枝构件
     * @param component
     */
    public void add(Component component) {
        this.componentList.add(component);
    }

    /**
     * 删除一个叶子构件或者树枝构件
     * @param component
     */
    public void remove(Component component){
        this.componentList.remove(component);
    }

    /**
     * 获得分支下所有叶子构件和树枝构件
     * @return
     */
    public List<Component> getChildren(){
        return this.componentList;
    }

}

  树叶构件：

package com.jack.component;

/**
 * Created by jack on 2018/1/26.
 */
public class Leaf extends Component {
    @Override
    public void doSomething() {
        //覆盖写父类的方法
        System.out.println("this is leaf ");
    }
}

测试主类：

package com.jack.component;

/**
 * Created by jack on 2018/1/26.
 */
public class Client {
    public static void main(String[] args) {
        //创建一个根节点
        Composite root = new Composite();
        root.doSomething();
        //创建一个树枝构件
        Composite branch = new Composite();
        //创建一个叶子节点
        Leaf leaf = new Leaf();
        root.add(branch);
        branch.add(leaf);
        display(root);
    }

    public static void display(Composite root) {
        for (Component component : root.getChildren()) {
            if (component instanceof Leaf) {//叶子节点
                component.doSomething();
            } else {
                //树枝节点
                display((Composite) component);

            }
        }
    }

}

二 组合模式的应用

1 组合模式的优点

1）高层模块调用简单

     一棵树行机构的所有节点都是Component，局部和整体对调用者来说没有任何区别，也就是说，高层模块不必关心自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。

2）节点自由增加

      使用了组合模式后，我们可以看看，如果想增加一个树枝节点，树叶节点是不是很容易，只要找到它的父节点就成了，非常容易扩展，符合开闭原则，对以后
的维护非常有利

2 组合模式的缺点

       组合模式有一个非常明显的缺点，看到我们在场景类中定义，直接使用了实现类，这在面向接口编程上是很不恰当的，与
依赖倒置原则冲突，读者在使用的时候要考虑清楚，它限制了你接口的影响范围

3 组合模式的使用场景

1）维护和展示部分-整体关系的场景，如树形菜单，文件和文件夹管理
2）从一个整体中能够独立出部分模块或功能的场景

4 组合模式的注意事项

只要是树形结构，就要考虑使用组合模式，这个一定要记住，只要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧

三 透明的组合模式

    组合模式有两种不同的实现：透明模式和安全模式，上面讲的是安全模式，那透明模式是什么样子了？透明模式的通用类图如下：

         透明模式是把用了组合使用的方法放到抽象类中，比如add，remove等方法。不管叶子对象还是树枝对象都有相同的结构，通过判断是getChildren的返回值确认是叶子节点还是树枝节点，如果处理不当，这个会在运行期间出现问题，不是很建议的方式；安全模式就不同了，它是把树枝节点和树叶节点彻底分开，树枝节点单独拥有用来组合的方法，这种方法比较安全，上面的例子使用了安全模式。

       由于透明模式的使用也比较多，下面实现组合模式的透明方式，代码如下：

抽象构建：

package com.jack.component;

import java.util.List;

/**
 * Created by jack on 2018/1/26.
 * 抽象构件
 */
public abstract class Component {
    //个体和整体都具有的共享
    public void doSomething(){
        //编写业务逻辑
        System.out.println("abstract do something");
    }

    /**
     * 增加一个叶子构件或者树枝构件
     * @param component
     */
    public abstract void add(Component component);

    /**
     * 删除一个叶子构件或者树枝构件
     * @param component
     */
    public abstract void remove(Component component);

    /**
     * 获得分支下所有叶子构件和树枝构件
     * @return
     */
    public abstract List<Component> getChildren();


}

树枝节点：

package com.jack.component;

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

/**
 * Created by jack on 2018/1/26.
 */
public class Composite extends Component {
    //构建容器
    private List<Component> componentList = new ArrayList<>();

    /**
     * 增加一个叶子构件或者树枝构件
     * @param component
     */
    public void add(Component component) {
        this.componentList.add(component);
    }

    /**
     * 删除一个叶子构件或者树枝构件
     * @param component
     */
    public void remove(Component component){
        this.componentList.remove(component);
    }

    /**
     * 获得分支下所有叶子构件和树枝构件
     * @return
     */
    public List<Component> getChildren(){
        return this.componentList;
    }

}

树叶节点：

package com.jack.component;

import java.util.List;

/**
 * Created by jack on 2018/1/26.
 */
public class Leaf extends Component {
    @Override
    public void doSomething() {
        //覆盖写父类的方法
        System.out.println("this is leaf ");
    }

    @Override
    public void add(Component component) throws UnsupportedOperationException{
        //空实现
        throw new UnsupportedOperationException();
    }

    @Override
    public void remove(Component component)throws UnsupportedOperationException {
        //空实现
        throw new UnsupportedOperationException();
    }

    @Override
    public List<Component> getChildren() throws UnsupportedOperationException{
        //空实现
        throw new UnsupportedOperationException();
        //return null;
    }
}

测试代码和上面基本差不多，主要修改了display方法，代码如下：

package com.jack.component;

/**
 * Created by jack on 2018/1/26.
 */
public class Client {
    public static void main(String[] args) {
        //创建一个根节点
        Composite root = new Composite();
        root.doSomething();
        //创建一个树枝构件
        Composite branch = new Composite();
        //创建一个叶子节点
        Leaf leaf = new Leaf();
        root.add(branch);
        branch.add(leaf);
        display(root);
    }

    public static void display(Component root) {
        for (Component component : root.getChildren()) {
            if (component instanceof Leaf) {//叶子节点
                component.doSomething();
            } else {
                //树枝节点
                //display((Composite) component);
                display(component);

            }
        }
    }

}