大话设计模式——组合模式

组合模式

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

Component

Component为组合中的对象声明接口,在适当情况下,实现所有类共有接口的默认行为。声明一个类用于访问和管理Component的子部件。

public abstract class Component {
    protected String name;
    public Component(String name) {
        this.name = name;
    }
    // 通常都用add和remove方法来提供增加或移除树叶或树枝的功能
    public abstract void add(Component c);
    public abstract void remove(Component c);
    public abstract void display(int depth);
}

Leaf

Leaf在组合中表示叶节点对象,叶节点没有子节点

public class Leaf extends Component {

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

    /**
     * 由于叶子没有再增加分支和树叶,所以add和remove方法实现它没有意义,但这样做可以消除叶节点和枝节点对象在抽象层次的 区别,它们具备完全一致的接口。
     */
    @Override
    public void add(Component c) {
        System.out.println("Cannot add to a leaf");
    }

    @Override
    public void remove(Component c) {
        System.out.println("Cannot remove to a leaf");
    }

    /**
     * 叶节点的具体方法,此处是显示其名称和级别
     */
    @Override
    public void display(int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("-");
        }
        System.out.println(name);
    }

}

Composite

Composite定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关的操作,比如增加add和删除remove。

public class Composite extends Component {

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

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

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

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

    /**
     * 显示其枝节点名称,并对其下级进行遍历
     */
    @Override
    public void display(int depth) {
        for(int i=0;i<depth;i++) {
            System.out.print("-");
        }
        System.out.println(name);
        for (Component component : children) {
            component.display(depth + 2);
        }
    }

}

客户端

客户端代码,能通过Component接口操作组合部件的对象。

public class Client {
    public static void main(String[] args) {
        // 生成树枝root,根上长出两叶LeafA和LeafB
        Composite root = new Composite("root");
        root.add(new Leaf("Leaf A"));
        root.add(new Leaf("Leaf B"));
        // 根上长出分支Composite X,分枝上也有两叶LeafXA和LeafXB
        Composite comp = new Composite("Composite X");
        comp.add(new Leaf("Leaf XA"));
        comp.add(new Leaf("Leaf XB"));
        root.add(comp);

        // 在Composite X上再长出分枝Composite XY,分枝上也有两叶LeafXYA和LeafXYB
        Composite comp2 = new Composite("Composite XY");
        comp2.add(new Leaf("Leaf XYA"));
        comp2.add(new Leaf("Leaf XYB"));
        comp.add(comp2);

        // 根部又长出两叶LeafC和leafD,可惜LeafD没长牢,被风吹走了
        root.add(new Leaf("Leaf C"));

        Leaf leaf = new Leaf("Leaf D");
        root.add(leaf);
        root.remove(leaf);

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

}

在这里插入图片描述

透明方式与安全方式

为什么Leaf类当中也有add和remove,树叶不是不可以再长分支吗?

这种方式叫做透明方式,也就是说在Component中声明所有用来管理子对象的方法,其中包括add、remove等。

这样实现Component接口的所有子类都具备了add和remove。这样做的好处就是叶节点和枝节点对于外界没有区别,它们具备完全一致的行为接口。但问题也很明显,因为leaf类本身不具备add、remove方法的功能,所以实现它是没有意义的。

如果不希望Leaf类当中不用add和remove方法,可以吗?

需要使用安全方式,即在Component接口中不去声明add和remove方法,那么子类的leaf也就不需要去实现它,而是在Composite声明所有用来管理子类对象的方法,不过由于不够透明,所以树叶和树枝类将不具有相同的接口,客户端的调用需要做相应的判断,带来了不便。

何时使用组合模式?

当你发现需求中是体现部分与整体层次结构的结构时,以及你希望用户可以忽略组合对象与单个对象的不同,统一地使用组合结构中的所有对象时,就应该考虑用组合模式了。

公司管理系统

公司类

/**
 * 公司类,抽象类或接口
 */
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(); // 履行职责
}

具体公司类

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

/**
 * 具体公司类 实现接口 树枝节点
 */
public class ConcreteCompany extends Company {

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

    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.println(name);
        for (Company company : children) {
            company.display(depth + 2);
        }
    }

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

}

人力资源部

/**
 * 人力资源部:树叶节点
 */
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.println(name);
    }

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

}

财务部

/**
 * 财务部:树叶节点
 */
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.println(name);
    }

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

}

客户端

public class Client {
    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("结构图:");
        root.display(1);
        System.out.println("职责:");
        root.lineOfDuty();

    }
}

在这里插入图片描述

组合模式好处

组合模式定义了包含人力资源部和财务部这些基本对象和分公司、办事处等组合对象的类层次结构。基本对象可以被组合到更复杂的组合对象,而这个组合对象又可以被组合,这样不断地递归下去,客户代码中,任何用到基本对象的地方都可以使用组合对象了。

用户是不用关心到底是处理一个叶节点还是处理一个组合组件,也就用不着为定义组合而写一些选择判断语句了。组合模式让客户可以一致地使用组合结构和单个对象。

注:本文内容源自程杰的《大话设计模式》

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值