-组合模式

组合模式

定义

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

解决

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

优点

• 高层模块调用简单，
• 节点自由增加。
• 一致性的使用组合结构和单个个体。

缺点

• 在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

结构

组合模式包含如下角色：

• Component: 部件接口类
• Leaf: 叶子类
• Composite: 枝节点类
  

实现

package compositemethod;
/**
 * Component为组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为。
 */
public abstract class Component {
    protected String name;

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

    public abstract void add(Component component);

    public abstract void remove(Component component);

    public abstract void display(int depth);
}

package compositemethod;
public class Leaf extends Component{
    public Leaf(String name) {
        super(name);
    }

    //由于叶子没有再增加分枝和树叶，所以add和remove方法实现它没有意义，但
    //这样做可以消除叶节点和枝节点再抽象层次的区别，他们具备完全一致的接口。
    @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 from a leaf");
    }

    //叶节点的具体方法
    @Override
    public void display(int depth) {
        // 通过“-”的数目显示级别
        for (int i=0;i<=depth;i ++)
            System.out.print("-");
        System.out.print(this.name);
        System.out.println();
    }
}

package compositemethod;
import java.util.ArrayList;
import java.util.List;

public class Composite extends Component{
    //一个子对象集合，用来存储其下属的枝节点和叶节点
    private List<Component> children = new ArrayList<Component>();

    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) {
        for (int i=0;i<=depth;i ++)
            System.out.print("-");
        System.out.print(this.name);
        System.out.println();

        // 显示其枝节点名称，并对其下级进行遍历
        for (Component component : children) {
            component.display(depth + 2);
        }
    }
}

package compositemethod;
/**
 * 客户端。能通过Component接口操作组合部件的对象
 */
public class CompositeClient {
    public static void main(String[] args) {
        // 生成树根，根上长出两叶Leaf A和Leaf B
        Composite root = new Composite("root");
        root.add(new Leaf("Leaf A"));
        root.add(new Leaf("Leaf B"));

        // 根上长出分支Composite X，分支上也有两叶Leaf X-A和Leaf X-B
        Composite comp = new Composite("Composite X");
        comp.add(new Leaf("Leaf X-A"));
        comp.add(new Leaf("Leaf X-B"));
        root.add(comp);

        // 在Composite X上再长出分支Composite X-Y，分支上也有两叶Leaf X-Y-A和Leaf X-Y-B
        Composite comp2 = new Composite("Composite X-Y");
        comp2.add(new Leaf("Leaf X-Y-A"));
        comp2.add(new Leaf("Leaf X-Y-B"));
        comp.add(comp2);

        //根部又长出两叶LeafC和LeafD
        root.add(new Leaf("Leaf C"));
        Leaf leaf = new Leaf("Leaf D");
        root.add(leaf);
        //，可惜LeafD没长牢，飞走了
        root.remove(leaf);


        // 显示大树的样子
        root.display(1);
    }
}

实例

package compositemethod.demo;

/**
 * 抽象类    (Component)
 */
public abstract class Company {
    protected String name;
    public Company(String name)
    {
        this.name=name;
    }

    public abstract void add(Company c);
    public abstract void remove(Company c);
    public abstract void display(int depth);
    public abstract void lineOfDuty();//履行职责
}

package compositemethod.demo;
import java.util.ArrayList;
import java.util.List;

/**
 * 具体公司      (Composite)
 */
public class ConcreteCompany extends Company{
    private List<Company>children=new ArrayList<>();

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

    @Override
    public void add(Company c) {
        children.add(c);
    }

    @Override
    public void remove(Company c) {
        children.remove(c);
    }

    @Override
    public void display(int depth) {
        for (int i=0;i<=depth;i ++)
            System.out.print("-");
        System.out.print(this.name);
        System.out.println();

        // 显示其枝节点名称，并对其下级进行遍历
        for (Company company : children) {
            company.display(depth + 2);
        }
    }

    @Override
    public void lineOfDuty() {
        for(Company company :children)
        {
            company.lineOfDuty();
        }
    }
}

package compositemethod.demo;
/**
 * 人力资源部    (Leaf)
 */
public class HRDepartment extends Company{

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

    //叶子无添加删除
    @Override
    public void add(Company c) {}
    @Override
    public void remove(Company c) {}

    @Override
    public void display(int depth) {
        for (int i=0;i<=depth;i ++)
            System.out.print("-");
        System.out.print(this.name);
        System.out.println();
    }

    @Override
    public void lineOfDuty() {
        System.out.println(name+"员工招聘培训管理");
    }
}

package compositemethod.demo;
public class FinanceDepartment extends Company{

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

    //叶子无添加删除
    @Override
    public void add(Company c) { }
    @Override
    public void remove(Company c) { }

    @Override
    public void display(int depth) {
        for (int i=0;i<=depth;i ++)
            System.out.print("-");
        System.out.print(this.name);
        System.out.println();
    }

    @Override
    public void lineOfDuty() {
        System.out.println(name+"公司财务收支管理");
    }
}

package compositemethod.demo;

public class CompositeClient {
    public static void main(String[] args) {
        ConcreteCompany root = new ConcreteCompany("北京总公司");
        root.add(new HRDepartment("总公司人力资源部"));
        root.add(new FinanceDepartment("总公司财务部"));

        ConcreteCompany comp = new ConcreteCompany("华东分公司");
        comp.add(new HRDepartment("华东分公司人力资源部"));
        comp.add(new FinanceDepartment("华东分公司财务部"));
        root.add(comp);

        ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
        comp1.add(new HRDepartment("南京办事处人力资源部"));
        comp1.add(new FinanceDepartment("南京办事处财务部"));
        comp.add(comp1);

        ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
        comp2.add(new HRDepartment("杭州办事处人力资源部"));
        comp2.add(new FinanceDepartment("杭州办事处财务部"));
        comp.add(comp2);

        System.out.println("\n结构图");
        root.display(1);

        System.out.println("\n职责");
        root.lineOfDuty();
    }
}

总结

• 组合模式定义了分枝和叶子等组合对象的类层次结构。叶子可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去，客户代码中，任何用到叶子的地方都可以使用组合对象。
• 用户不用关心到底是处理一个叶节点还是处理一个组合组件，也就用不着为定义组合而写一些选择判断语句。
• 使得用户对单个对象和组合对象的使用具有一致性。