设计模式之禅【组合模式】

最新推荐文章于 2022-04-14 14:53:50 发布
最新推荐文章于 2022-04-14 14:53:50 发布
阅读量747 收藏
点赞数
分类专栏： 设计模式专栏 设计模式之禅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eieiei438/article/details/79031986
版权

真刀实枪之组合模式

  • 从公司的人事架构谈起吧
    • 公司的组织架构
    • 从上图中可以分析出：
      1. 有分支的节点（树枝节点）
      2. 无分支的节点（叶子节点）
      3. 根节点（无父节点）
  • 有了树状结构图，再看看类图长啥样吧！

  • 这个类图是有缺陷的，等会儿继续修改，现在先看下这个不成熟类图的代码

    • IRoot

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface IRoot {
    // 得到总经理想要的信息
    public String getInfo();

    // 添加树枝节点
    public void add(IBranch banch);

    // 添加叶子节点
    public void add(ILeaf leaf);

    // 遍历节点
    public ArrayList getSubordinateInfo();
}

    • Root

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Root implements IRoot {
    // 保存根节点下的树枝节点和叶子节点
    private ArrayList subordinateList = new ArrayList();
    // 根节点的名称
    private String name = "";
    // 根节点的职位
    private String position = "";
    // 根节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的总经理的信息
    Root(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info += "根节点名称：" + this.name + "，根节点职位：" + this.position + "，根节点薪水："
                + this.salary;
        return info;
    }

    @Override
    public void add(IBranch branch) {
        this.subordinateList.add(branch);
    }

    @Override
    public void add(ILeaf leaf) {
        this.subordinateList.add(leaf);
    }

    @Override
    public ArrayList getSubordinateInfo() {
        return this.subordinateList;
    }

}

    • IBranch

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface IBranch {
    // 得到信息
    public String getInfo();

    // 添加树枝节点
    public void add(IBranch banch);

    // 添加叶子节点
    public void add(ILeaf leaf);

    // 遍历节点
    public ArrayList getSubordinateInfo();
}

    • Branch

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Branch implements IBranch {

    // 保存树枝节点下的树枝节点和叶子节点
    private ArrayList subordinateList = new ArrayList();
    // 树枝节点的名称
    private String name = "";
    // 树枝节点的职位
    private String position = "";
    // 树枝节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的树枝节点的信息
    Branch(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                + this.salary;
        return info;
    }

    @Override
    public void add(IBranch branch) {
        this.subordinateList.add(branch);
    }

    @Override
    public void add(ILeaf leaf) {
        this.subordinateList.add(leaf);
    }

    @Override
    public ArrayList getSubordinateInfo() {
        return this.subordinateList;
    }

}

    • ILeaf

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface ILeaf {
    // 得到信息
    public String getInfo();

}

    • Leaf

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Leaf implements ILeaf {
    // 叶子节点的名称
    private String name = "";
    // 叶子节点的职位
    private String position = "";
    // 叶子节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的叶子节点的信息
    Leaf(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info += "叶子节点名称：" + this.name + "，叶子节点职位：" + this.position + "，叶子节点薪水："
                + this.salary;
        return info;
    }

}

    • Client

      package com.peng.zh;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Client {

    public static void main(String[] args) {
        // 先产生根节点
        IRoot ceo = new Root("王大麻子", "总经理", 100000);
        // 产生三个部门经理
        IBranch developDep = new Branch("刘大瘸子", "研发部门经理", 10000);
        IBranch salesDep = new Branch("马二拐子", "销售部门经理", 20000);
        IBranch financeDep = new Branch("赵三驼子", "财务部门经理", 30000);
        // 两个小组长
        IBranch firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
        IBranch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
        // 研发部经理
        ILeaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
        // 员工
        ILeaf a = new Leaf("a", "开发人员", 2000);
        ILeaf b = new Leaf("b", "开发人员", 2000);
        ILeaf c = new Leaf("c", "开发人员", 2000);
        ILeaf d = new Leaf("d", "开发人员", 2000);
        ILeaf e = new Leaf("e", "开发人员", 2000);
        ILeaf f = new Leaf("f", "开发人员", 2000);
        ILeaf g = new Leaf("g", "开发人员", 2000);
        ILeaf h = new Leaf("h", "销售人员", 5000);
        ILeaf i = new Leaf("i", "销售人员", 4000);
        ILeaf j = new Leaf("j", "财务人员", 5000);
        ILeaf k = new Leaf("k", "ceo秘书人员", 8000);
        // 组装总经理
        ceo.add(developDep);
        ceo.add(salesDep);
        ceo.add(financeDep);
        ceo.add(k);
        // 组装研发部门
        developDep.add(firstDepGroup);
        developDep.add(secondDepGrooup);
        developDep.add(zhengLaoLiu);
        // 组装第一个开发小组
        firstDepGroup.add(a);
        firstDepGroup.add(c);
        firstDepGroup.add(d);
        // 组装第二个开发小组
        secondDepGrooup.add(e);
        secondDepGrooup.add(f);
        secondDepGrooup.add(g);
        // 组装销售部
        salesDep.add(h);
        salesDep.add(i);
        // 组装财务部
        financeDep.add(j);
        // 打印出来整个树形结构
        System.out.println(ceo.getInfo());
        getAllSubordinateInfo(ceo.getSubordinateInfo());

    }

    private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
        int length = subordinateInfo.size();
        for (int i = 0; i < length; i++) {
            Object s = subordinateInfo.get(i);
            if (s instanceof Leaf) {
                ILeaf employee = (ILeaf) s;
                System.out.println(employee.getInfo());
            } else {
                IBranch branch = (IBranch) s;
                System.out.println(branch.getInfo());
                // 递归
                getAllSubordinateInfo(branch.getSubordinateInfo());
            }
        }
    }

}
    • 执行结果 
      根节点名称：王大麻子，根节点职位：总经理，根节点薪水：100000
树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
叶子节点名称：a，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：c，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：d，叶子节点职位：开发人员，叶子节点薪水：2000
树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
叶子节点名称：e，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：f，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：g，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：郑老六，叶子节点职位：研发部副总，叶子节点薪水：20000
树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
叶子节点名称：h，叶子节点职位：销售人员，叶子节点薪水：5000
叶子节点名称：i，叶子节点职位：销售人员，叶子节点薪水：4000
树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
叶子节点名称：j，叶子节点职位：财务人员，叶子节点薪水：5000
叶子节点名称：k，叶子节点职位：ceo秘书人员，叶子节点薪水：8000
  • 好，代码写完，把刚刚遗留的问题来找一下：
    1. getInfo每个接口都有，为什么不抽象出来？
    2. Root和Branch类有什么差别？
    3. 根节点本来就是树枝节点的一种，为什么要定义成两个接口？
    4. 若果我要增加一个任职期限，是不是所有的都要修改？
    5. 如果我要后续遍历，能做到吗？

  • 问题很多，一个一个解决

    1. 先说抽象问题，确实可以抽象出来，修改下类图

      1. 修改
      2. 仔细看这个图，能不能发现还有问题--想想接口的作用是什么？定义共性，既然是这样，那getInfo方法也可以封装啦，再继续修改
      3. 修改2
      4. 类图上增加了一个ICorp接口，它是公司所有员工的接口类

      5. 新类图的代码

        1. ICorp

          package zh2;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface ICorp {
    // 获取信息
    public String getInfo();
}

        2. ILeaf

          package zh2;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface ILeaf extends ICorp {

}

        3. Leaf

          package zh2;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Leaf implements ILeaf {

    // 叶子节点的名称
    private String name = "";
    // 叶子节点的职位
    private String position = "";
    // 叶子节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的叶子节点的信息
    Leaf(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info += "叶子节点名称：" + this.name + "，叶子节点职位：" + this.position + "，叶子节点薪水："
                + this.salary;
        return info;
    }

}

        4. IBranch

          package zh2;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public interface IBranch extends ICorp {
    // 增高增加小兵
    public void addSubordinate(ICorp corp);

    // 获得下属信息
    public ArrayList<ICorp> getSubordinate();
    // 删除下属--没用到，这里省略
}

        5. Branch

          package zh2;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Branch implements IBranch {
    // 保存节点下的树枝节点和叶子节点
    private ArrayList<ICorp> subordinateList = new ArrayList<ICorp>();
    // 树枝节点的名称
    private String name = "";
    // 树枝节点的职位
    private String position = "";
    // 树枝节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的树枝节点的信息
    Branch(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                + this.salary;
        return info;
    }

    @Override
    public void addSubordinate(ICorp corp) {
        this.subordinateList.add(corp);
    }

    @Override
    public ArrayList<ICorp> getSubordinate() {
        return this.subordinateList;
    }

}

        6. Client

          package zh2;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月24日
 * @description
 */
public class Client {
    public static void main(String[] args) {

        // 先产生根节点
        Branch ceo = new Branch("王大麻子", "总经理", 100000);
        // 产生三个部门经理
        IBranch developDep = new Branch("刘大瘸子", "研发部门经理", 10000);
        IBranch salesDep = new Branch("马二拐子", "销售部门经理", 20000);
        IBranch financeDep = new Branch("赵三驼子", "财务部门经理", 30000);
        // 两个小组长
        IBranch firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
        IBranch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
        // 研发部经理
        ILeaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
        // 员工
        ILeaf a = new Leaf("a", "开发人员", 2000);
        ILeaf b = new Leaf("b", "开发人员", 2000);
        ILeaf c = new Leaf("c", "开发人员", 2000);
        ILeaf d = new Leaf("d", "开发人员", 2000);
        ILeaf e = new Leaf("e", "开发人员", 2000);
        ILeaf f = new Leaf("f", "开发人员", 2000);
        ILeaf g = new Leaf("g", "开发人员", 2000);
        ILeaf h = new Leaf("h", "销售人员", 5000);
        ILeaf i = new Leaf("i", "销售人员", 4000);
        ILeaf j = new Leaf("j", "财务人员", 5000);
        ILeaf k = new Leaf("k", "ceo秘书人员", 8000);
        // 组装总经理
        ceo.addSubordinate(developDep);
        ceo.addSubordinate(salesDep);
        ceo.addSubordinate(financeDep);
        ceo.addSubordinate(k);
        // 组装研发部门
        developDep.addSubordinate(firstDepGroup);
        developDep.addSubordinate(secondDepGrooup);
        developDep.addSubordinate(zhengLaoLiu);
        // 组装第一个开发小组
        firstDepGroup.addSubordinate(a);
        firstDepGroup.addSubordinate(c);
        firstDepGroup.addSubordinate(d);
        // 组装第二个开发小组
        secondDepGrooup.addSubordinate(e);
        secondDepGrooup.addSubordinate(f);
        secondDepGrooup.addSubordinate(g);
        // 组装销售部
        salesDep.addSubordinate(h);
        salesDep.addSubordinate(i);
        // 组装财务部
        financeDep.addSubordinate(j);
        // 打印出来整个树形结构
        System.out.println(ceo.getInfo());
        getAllSubordinateInfo(ceo.getSubordinate());

    }

    private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
        int length = subordinateInfo.size();
        for (int i = 0; i < length; i++) {
            Object s = subordinateInfo.get(i);
            if (s instanceof Leaf) {
                ILeaf employee = (ILeaf) s;
                System.out.println(employee.getInfo());
            } else {
                IBranch branch = (IBranch) s;
                System.out.println(branch.getInfo());
                // 递归
                getAllSubordinateInfo(branch.getSubordinate());
            }
        }
    }
}
        7. 执行结果 
          树枝节点名称：王大麻子，树枝节点职位：总经理，树枝节点薪水：100000
树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
叶子节点名称：a，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：c，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：d，叶子节点职位：开发人员，叶子节点薪水：2000
树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
叶子节点名称：e，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：f，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：g，叶子节点职位：开发人员，叶子节点薪水：2000
叶子节点名称：郑老六，叶子节点职位：研发部副总，叶子节点薪水：20000
树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
叶子节点名称：h，叶子节点职位：销售人员，叶子节点薪水：5000
叶子节点名称：i，叶子节点职位：销售人员，叶子节点薪水：4000
树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
叶子节点名称：j，叶子节点职位：财务人员，叶子节点薪水：5000
叶子节点名称：k，叶子节点职位：ceo秘书人员，叶子节点薪水：8000

      6. getInfo方法都有，是不是可以继续优化，把ICorp接口变化成一个抽象类，将getInfo方法在抽象类中实现

        1. 再次修改类图

        2. 代码实现

          1. Corp

            package zh3;


/**
 * @author kungfu~peng
 * @data 2017年11月25日
 * @description
 */
public abstract class Corp {
    // 树枝节点的名称
    private String name = "";
    // 树枝节点的职位
    private String position = "";
    // 树枝节点的薪水
    private int salary = 0;

    // 通过构造函数传递进来的树枝节点的信息
    Corp(String name, String position, int salary) {
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    public String getInfo() {
        String info = "";
        info += "树枝节点名称：" + this.name + "，树枝节点职位：" + this.position + "，树枝节点薪水："
                + this.salary;
        return info;
    }

}

          2. Branch

            package zh3;

import java.util.ArrayList;

import zh2.ICorp;

/**
 * @author kungfu~peng
 * @data 2017年11月25日
 * @description
 */
public class Branch extends Corp {
    // 保存节点下的树枝节点和叶子节点
    private ArrayList<Corp> subordinateList = new ArrayList<Corp>();

    Branch(String name, String position, int salary) {
        super(name, position, salary);
    }

    // 增加下属
    public void addSubordinate(Corp corp) {
        this.subordinateList.add(corp);
    }

    // 我有哪些下属
    public ArrayList<Corp> getSubordinate() {
        return this.subordinateList;
    }
}

          3. Leaf

            package zh3;

/**
 * @author kungfu~peng
 * @data 2017年11月25日
 * @description
 */
public class Leaf extends Corp {

    Leaf(String name, String position, int salary) {
        super(name, position, salary);
    }

}

          4. Client

            package zh3;

import java.util.ArrayList;

/**
 * @author kungfu~peng
 * @data 2017年11月25日
 * @description
 */
public class Client {

    public static void main(String[] args) {

        // 先产生根节点
        Branch ceo = new Branch("王大麻子", "总经理", 100000);
        // 产生三个部门经理
        Branch developDep = new Branch("刘大瘸子", "研发部门经理", 10000);
        Branch salesDep = new Branch("马二拐子", "销售部门经理", 20000);
        Branch financeDep = new Branch("赵三驼子", "财务部门经理", 30000);
        // 两个小组长
        Branch firstDepGroup = new Branch("杨三也斜", "开发一组组长", 5000);
        Branch secondDepGrooup = new Branch("吴大棒槌", "开发二组组长", 6000);
        // 研发部经理
        Leaf zhengLaoLiu = new Leaf("郑老六", "研发部副总", 20000);
        // 员工
        Leaf a = new Leaf("a", "开发人员", 2000);
        Leaf b = new Leaf("b", "开发人员", 2000);
        Leaf c = new Leaf("c", "开发人员", 2000);
        Leaf d = new Leaf("d", "开发人员", 2000);
        Leaf e = new Leaf("e", "开发人员", 2000);
        Leaf f = new Leaf("f", "开发人员", 2000);
        Leaf g = new Leaf("g", "开发人员", 2000);
        Leaf h = new Leaf("h", "销售人员", 5000);
        Leaf i = new Leaf("i", "销售人员", 4000);
        Leaf j = new Leaf("j", "财务人员", 5000);
        Leaf k = new Leaf("k", "ceo秘书人员", 8000);
        // 组装总经理
        ceo.addSubordinate(developDep);
        ceo.addSubordinate(salesDep);
        ceo.addSubordinate(financeDep);
        ceo.addSubordinate(k);
        // 组装研发部门
        developDep.addSubordinate(firstDepGroup);
        developDep.addSubordinate(secondDepGrooup);
        developDep.addSubordinate(zhengLaoLiu);
        // 组装第一个开发小组
        firstDepGroup.addSubordinate(a);
        firstDepGroup.addSubordinate(c);
        firstDepGroup.addSubordinate(d);
        // 组装第二个开发小组
        secondDepGrooup.addSubordinate(e);
        secondDepGrooup.addSubordinate(f);
        secondDepGrooup.addSubordinate(g);
        // 组装销售部
        salesDep.addSubordinate(h);
        salesDep.addSubordinate(i);
        // 组装财务部
        financeDep.addSubordinate(j);
        // 打印出来整个树形结构
        System.out.println(ceo.getInfo());
        getAllSubordinateInfo(ceo.getSubordinate());

    }

    private static void getAllSubordinateInfo(ArrayList subordinateInfo) {
        int length = subordinateInfo.size();
        for (int i = 0; i < length; i++) {
            Object s = subordinateInfo.get(i);
            if (s instanceof Leaf) {
                Leaf employee = (Leaf) s;
                System.out.println(employee.getInfo());
            } else {
                Branch branch = (Branch) s;
                System.out.println(branch.getInfo());
                // 递归
                getAllSubordinateInfo(branch.getSubordinate());
            }
        }
    }
}
          5. 执行结果 
            树枝节点名称：王大麻子，树枝节点职位：总经理，树枝节点薪水：100000
树枝节点名称：刘大瘸子，树枝节点职位：研发部门经理，树枝节点薪水：10000
树枝节点名称：杨三也斜，树枝节点职位：开发一组组长，树枝节点薪水：5000
树枝节点名称：a，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：c，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：d，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：吴大棒槌，树枝节点职位：开发二组组长，树枝节点薪水：6000
树枝节点名称：e，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：f，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：g，树枝节点职位：开发人员，树枝节点薪水：2000
树枝节点名称：郑老六，树枝节点职位：研发部副总，树枝节点薪水：20000
树枝节点名称：马二拐子，树枝节点职位：销售部门经理，树枝节点薪水：20000
树枝节点名称：h，树枝节点职位：销售人员，树枝节点薪水：5000
树枝节点名称：i，树枝节点职位：销售人员，树枝节点薪水：4000
树枝节点名称：赵三驼子，树枝节点职位：财务部门经理，树枝节点薪水：30000
树枝节点名称：j，树枝节点职位：财务人员，树枝节点薪水：5000
树枝节点名称：k，树枝节点职位：ceo秘书人员，树枝节点薪水：8000

组合模式的定义

  • Composite Pattern
  • 也叫合成模式或整体-部分模式，主要是描述部分与整体的关系
  • Compose objects into tree structures to represent part-whole hirearchies.Composite lets clients treat individual objects and compositions of objects uniformly.(将对象组合成树形结构，以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性)

通用类图

  • 几个角色
    1. Component抽象构建角色：可以定义属性和方法
    2. Leaf叶子构件：遍历的最小单位
    3. Composite树枝构件：中间节点或根节点
  • 通用代码这里不再赘述

组合模式的应用

  • 组合模式的优点
    1. 高层模块调用简单
    2. 节点自由增加
  • 组合模式的缺点
    1. 场景类直接使用了树叶节点和树枝节点，这在面向接口编程上是很不恰当的，与依赖原则冲突
  • 使用场景
    1. 维护和展示“部分-整体”关系的场景--树形菜单、文件和文件夹管理
    2. 从一个整体中能够独立出部分模块或功能的场景

组合模式的注意事项

  • 只要是树形结构就考虑组合模式--体现“部分-整体”关系的时候

组合模式的扩展

  • 安全模式的组合模式【之前写的就是】
  • 透明的组合模式
    • 类图
      • 透明模式就是将组合使用的方法放到抽象类中，不管是叶子还是树枝都有这个方法，通过判断getChild的返回值确定是叶子节点还是树枝节点，如果处理不当，运行期间会出问题
      • 不是很建议这种方式
      • 代码--注意叶子节点的add方法的重写--抛出“不支持请求异常”即可--throw new UnsupportedOperationException();
  • 组合模式的遍历
    1. 上到下【上面的已经实现】
    2. 下到上【增加parent】
      1. 类图
        1. ​​​​​​​
      2. 代码（看了这么多，自己动手试一试）

最佳实践

  • 页面结构【top，center（left，right），bottom】
  • JavaScript
  • xml
  • 血缘关系

声明

  • 摘自秦小波《设计模式之禅》第2版；
  • 仅供学习，严禁商业用途；
  • 代码手写，没有经编译器编译，有个别错误，自行根据上下文改正；
乘风御浪云帆之上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《设计模式之禅》——组合模式
零下九度
01-26 772
组合模式：将对象组合成树形结构以表示“部分-整理”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
设计模式之---享元模式
路漫漫 始于足下
05-05 372
下面来个实例，大家应该就明白了。 package flyweight; public interface Flyweight { void operate(); } package flyweight; public class FlyweightA implements Flyweight { @Override public void operate() { // TODO
设计模式之禅电子版（百度网盘下载【包含链接与提取码】）
06-08
设计模式之禅，一种思想书，会一直受益，初学，工作一年，三年认识都不一样。 也算是软件开发的思想启蒙，看书介绍说：能让你设计一个优秀的代码结构，写一段健壮的代码，比较容易的解决一些复杂的需求。
《设计模式之禅》(第2版)
墨雨的博客
06-27 2439
第一部分 大旗不挥 谁敢冲锋 —— 6大设计原则全新解读 第1章 单一职责原则 单一职责原则，SingleResponsibilityPrinciple，简称SRP，有且只有一个原因引起类/接口的变更；即一个接口/类只有一个职责，只负责一件事情。 单一职责的好处： 类的复杂性降低。实现什么职责都有清晰明确的定义； 可读性提高，复杂性降低； 可维护性提高； 变更引起的风险降低 面向接口编程，对于接口的设计要求接口职责做到单一。 单一职责原则使用于接口、类，同时使用于方法。保证一个方法...
设计模式之禅-思考上
zhangxi1224的博客
07-29 327
6大基本原则 程序是面向现实的抽象。 单一职责：类的功能尽量单一，职责单一，只干一类事情。应该有且仅有一个原因引起类的变更。这个要根据实际项目来设计 类的职责。尽量做到单一。 里式替换 ：所有引用基类的地方必须能透明的使用其子类的对象。就是说 有可能变化的地方，和耦合的地方 尽量使用 接口或者抽象父类 声明参数。这样后期容易修改。 依赖倒置 ：高层模块不应该依赖低层模块，两者都应该依赖其抽象。抽象...
c++之工厂方法模式
c_shell_python的博客
06-16 400
工厂方法模式定义 定义一个用于创建对象的接口，让子类决定实例化哪一个类。核心结构分别是抽象工厂以及具体工厂，抽象产品以及具体产品。 #include <iostream> using namespace std; //抽象产品 class IWine { public: virtual ~IWine(){} virtual void createWine() = 0; }; //抽象工厂类 class IFactory { public: virtual ~IFactory()
设计模式之禅学习笔记
come and experience the world of code, communicate and exchange ideas with everyone, and unleash new ideas together～
04-14 399
设计模式 一，六大设计原则[SOLID] 1，单一职责[SRP]：应该有且仅有一个原因引起类的变更。 "职责"和"变化原因"都是不可度量的，因项目和实际环境而异。 如果要实现类的单一职责，会引起类间耦合过重，类数量增加； 可进行接口的单一职责设计，实现类实现多个单一职责接口，面向接口编程。 建议接口一定做到单一职责，类尽量做到单一职责。 单一职责的好处： 1，类的复杂性降低； 2，可读性提高； 3，可维护性提高； 4，变更引起的风险降低，接口的修改只会影响对应实现类，不会影响其他接口。 2，里
设计者模式之禅第二版
03-28
《设计模式之禅（第2版）》是秦小波先生深入浅出地阐述软件设计模式的力作，尤其在第二版中，作者对原有的内容进行了更新和优化，旨在帮助读者更好地理解和应用设计模式，提升软件开发的效率和质量。设计模式是软件...
设计模式之禅之 组合模式
04-13
设计模式之禅之 组合模式 设计模式之禅之 组合模式 设计模式之禅之 组合模式 设计模式之禅之 组合模式
Java-Zen-of-Design.rar_zen_设计模式之禅
最新发布
09-20
《Java设计之禅》是关于Java软件设计的一部著作，主要探讨了在开发过程中如何运用设计模式提升代码质量、可维护性和可扩展性。设计模式是面向对象编程中的一种最佳实践，是解决常见问题的经验总结，它使得开发者能够...
Java设计模式之禅
04-07
设计模式相关内容，深入浅出可以一看的书籍。初学者可以下载看看
设计模式之蝉
11-29
高清版的设计模式之蝉（第二版），附个人看书笔记，Java语言。
java设计模式之禅
10-13
设计模式-轻松让你读懂java。包含java所有的设计模式，什么情况下应用什么样的设计模式。读者看完可以对java的设计模式有很好的了解，可以编写出低耦合的代码
JAVA设计模式之禅完整版
05-05
JAVA设计模式之禅完整版 JAVA设计模式之禅完整版 JAVA设计模式之禅完整版
C++设计模式之禅
08-25
C++设计模式之禅 ，学习设计模式必选按资料，很经典PDF资料。
设计模式之禅 设计模式
05-05
这些设计模式都是《设计模式之禅》中探讨的核心内容，它们提供了良好的编程思维，有助于编写出高质量、易于维护的代码。通过对这些模式的学习和应用，开发者可以更好地理解和解决软件开发中的各种挑战，提升软件工程...
设计模式之禅之+组合模式
04-01
设计面向对象软件比较困难，而设计可复用的面向对象软件就更加困难。你必须找到相 关的对象，以适当的粒度将它们归类，再定义类的接口和继承层次，建立对象之间的基本关 系。你的设计应该对手头的问题有针对性，同时...
设计模式之禅《一》 大旗不挥，谁敢冲锋 ——6大设计原则
shouji6175的博客
04-02 459
设计模式之禅《一》大旗不挥，谁敢冲锋 ——6大设计原则 《一》 六大原则 一：单一职责原则 1、单一职责原则最难划分的就是职责 2、有两个可以变化的原因放到了一个接口中，这就为以后的变化带来了风险。 3、对于单一职责原则，我的建议是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化。 禅：不同对象对同一个接口进行调用时，如果其中的某个方法产生不同的实现就应该把他抽离出来形成以自己为中心的新的职责。创建自己的接口时职责一定要清晰清晰！，单一，不要让别人猜测这个方法可能是用来处理什么逻辑的。 二：
设计模式之禅学习总结
zhanglu0302的博客
10-27 1351
设计模式之禅学习总结单一职责原则 SRP里式替换原则 LSP依赖倒置原则 DIP接口隔离原则迪米特法则LoD开闭原则：单例模式单例模式的通用类图如下图单例模式的优点单例模式的缺点单例模式的使用场景工厂模式工厂方法模式的通用类图工厂模式的优点工厂方法模式的使用场景工厂方法模式的扩展抽象工厂模式抽象工厂模式的通用类图抽象工厂模式的优点抽象工厂模式的缺点抽象工厂模式的使用场景抽象工厂模式的注意事项最佳实践模板方法模式模板方法模式的定义模板方法模式的优点模板方法模式的缺点模板方法模式的使用场景最佳实践建造者模式建造

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

乘风御浪云帆之上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值