组合模式之代码实现

已于 2023-02-26 18:01:09 修改
阅读量221 收藏
点赞数
分类专栏： #组合模式 文章标签： 开发语言 java net 组合模式 Powered by 金山文档
于 2023-01-26 12:37:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lj_chuxuezhe/article/details/128764823
版权

  1. 组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

  1. 如果不使用组合模式，客户端代码将过多地依赖于容器对象复杂的内部实现结构，容器对象内部实现结构的变化将引起客户代码的频繁变化，带来了代码维护复杂、可扩展性差等弊端。组合模式的引入将在一定程度上解决这些问题。

  1. 代码实现

public abstract class OrganizationComponet {
   private String name;
   private String des;
   protected void add(OrganizationComponet organizationComponet) {
      throw new UnsupportedOperationException();
   }
   protected void remove(OrganizationComponet organizationComponet) {
      throw new UnsupportedOperationException();
   }
   public OrganizationComponet(String name, String des) {
      super();
      this.name = name;
      this.des = des;
   }
   //print
   protected abstract void print();
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getDes() {
      return des;
   }
   public void setDes(String des) {
      this.des = des;
   }
   @Override
   public String toString() {
      return "OrganizationComponet [name=" + name + ", des=" + des + "]";
   }

    public OrganizationComponet() {
      super();
   }
}
///university 就是Composite，可以管理College
public class University extends OrganizationComponet{
   List<OrganizationComponet> organizationComponets = new ArrayList<OrganizationComponet>();
  
   //构造器
   public University(String name, String des) {
      super(name, des);
   // TODO Auto-generated constructor stub
   }

   @Override
   protected void add(OrganizationComponet organizationComponet) {
  
      organizationComponets.add(organizationComponet);
   }
   @Override
   protected void remove(OrganizationComponet organizationComponet) {
      // TODO Auto-generated method stub
      organizationComponets.remove(organizationComponet);
   }
   @Override
   public String getDes() {
      // TODO Auto-generated method stub
     return super.getDes();
   }

   @Override
   public String getName() {
      // TODO Auto-generated method stub
      return super.getName();
   }
   //输出university中包含的学院
   @Override
   protected void print() {
      System.out.println("----------"+getName()+"----------");
      for (OrganizationComponet o :organizationComponets){
         o.print();
      }
   }
}
public class College extends OrganizationComponet {
   List<OrganizationComponet> organizationComponets = new ArrayList<OrganizationComponet>();
   
   //构造器
   public College(String name, String des) {
      super(name, des);
      // TODO Auto-generated constructor stub
   }

   @Override
   protected void add(OrganizationComponet organizationComponet) {

       organizationComponets.add(organizationComponet);
   }
   @Override
   protected void remove(OrganizationComponet organizationComponet) {
       // TODO Auto-generated method stub
       organizationComponets.remove(organizationComponet);
   }
   @Override
   public String getDes() {
       // TODO Auto-generated method stub
       return super.getDes();
   }

   @Override
   public String getName() {
      // TODO Auto-generated method stub
      return super.getName();
   }
   //输出学院包含的系
   @Override
   protected void print() {
      System.out.println("----------"+getName()+"----------");
      for (OrganizationComponet o :organizationComponets){
         o.print();
      }
    }
}
public class Departent extends OrganizationComponet{
   public Departent(String name,String des) {
      super(name,des);
   }

   //add,remove 不需要在写，因为他是叶子节点
   @Override
   protected void print() {
      System.out.println(getName());

   }
   @Override
   public String getName() {
      // TODO Auto-generated method stub
      return super.getName();
   }
   @Override
   public String getDes() {
      // TODO Auto-generated method stub
      return super.getDes();
   }
}
public class Cilents {
    public static void main(String[] args) {
        //从大到小创建

        //学校
        OrganizationComponet university = new University("清华大学","顶级大学");
        
        //学院
        OrganizationComponet college1 = new College("计算机学院","计算机学院");
        OrganizationComponet college2 = new College("理学院","理学院");
        
        //专业
        college1.add(new Departent("软件工程","不错"));
        college1.add(new Departent("网络工程","不错"));
        college1.add(new Departent("计算机科学与技术","老排不错"));

        college2.add(new Departent("通信工程","发发发不错"));
        college2.add(new Departent("信息工程","很好学不错"));

         //将学院加入到学校
         university.add(college1);
         university.add(college2);

         university.print();
         System.out.println("===============================");
         college1.print();
   }
}

  1. 抽象构件角色

一般将抽象构件类设计为接口或抽象类，将所有子类共有方法的声明和实现放在抽象构件类中。对于客户端而言，将针对抽象构件编程，而无须关心其具体子类是容器构件还是叶子构件。

public abstract class Component {
/**
* 增加成员
* @param c
*/
public void add(Component c){
throw new UnsupportedOperationException();
}

/**
* 删除成员
* @param c
*/
public void remove(Component c){
throw new ();
}

/**
* 获取成员
* @param i
* @return
*/
public Component getChild(int i){
throw new ();
}

/**
* 业务方法
*/
public void operation(){
throw new ();
}
}

  1. 叶子构件

public class Leaf extends Component {
@Override
public void operation(){
System.out.println("子构件");
}
}

  1. 容器构件

public class Composite extends Component {
private List<Component> list = new ArrayList<Component>();

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

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

@Override
public Component getChild(int i) {
return list.get(i);
}

@Override
public void operation(){
for (Component child: list){
child.operation();
}
}
}

  1. 总结

  • 使用组合模式可以让用户可以使用统一的方式处理整个树形结构的个别对象和组合对象，从而简化客户端的操作。

  • 组合模式具有较强的扩展性，当我们想要更改组合对象时，只需要调整内部的层次关系即可，客户端不需要作出任何改动。

  • 客户端不用考虑组合中的细节，通过添加节点和叶子就可以创建出复杂的树形结构。

  • 当需要处理的对象是树形结构时可以考虑使用组合模式。

  • 节点和叶子节点存在很大差异的情况下不建议使用组合模式。

  1. 通过案例了解组合模式

深圳某公司总部使用的OA系统，由于简单易用，反响良好的原因，准备被推广到各分公司使用。

关于组织结构的设计，原来是这样的：一个公司总部下面有人力资源部、财务部等。

// 组织
public interface Organization {
    void addOrg(Department department);
    void removeOrg(Department department);
    String getName();
    void showOrg();
    void displayDuty();
}
// 公司总部
public class Headquarters implements  Organization {
    private List<Department> departments = new ArrayList<>();

    @Override
    public void addOrg(Department department) {
        departments.add(department);
    }

    @Override
    public void removeOrg(Department department) {
        departments.remove(department);
    }

    public String getName() {
        return this.getClass().getSimpleName();
    }

    @Override
    public void showOrg() {
        System.out.println("-" + getName());
        for (Department department : departments) {
            System.out.println("--" +  department.getName());
        }
    }

    @Override
    public void displayDuty() {
        for(Department department : departments) {
            department.duty();
        }
    }
}
// 部门
public interface Department {
    String getName();
    void duty();
}
// 财务部
public class FinanceDepartment implements Department {

    @Override
    public String getName() {
        return this.getClass().getSimpleName();
    }

    @Override
    public void duty() {
        System.out.println("财务部负责公司财务收支管理");
    }
}
// 人力资源部
public class HumanResourceDepartment implements Department{

    @Override
    public String getName() {
        return this.getClass().getSimpleName();
    }

    @Override
    public void duty() {
        System.out.println("人力资源部负责员工招聘培训管理");
    }
}
// 测试类
public class Before {
    public static void main(String[] args) {
        Organization hq = new Headquarters();

        Department fnc = new FinanceDepartment();

        Department hr = new HumanResourceDepartment();

        hq.addOrg(fnc);
        hq.addOrg(hr);

        System.out.println("====组织结构====");
        hq.showOrg();
        System.out.println("====部门职责====");
        hq.displayDuty();
    }
}

  • 应用组合模式的代码

// 公司组织或部门
public interface Company {

    void addOrg(Company company);
    void removeOrg(Company company);
    void showOrg(int depth);
    default void print(int dept) {
        while(dept-- > 0) {
            System.out.print("-");
        }
    }
}
// 总部或分公司
public class ConcreteComp implements Company {
    private String name = "";
    private List<Company> companies = new ArrayList<>();
    ConcreteComp(String name) {
        this.name = name;
    }

    @Override
    public void addOrg(Company company) {
        companies.add(company);
    }

    @Override
    public void removeOrg(Company company) {
        companies.remove(company);
    }

    @Override
    public void showOrg(int dept) {
        print(dept);
        System.out.println(this.name);
        for (Company c : companies) {
            c.showOrg(dept + 2);
        }
    }
}
// 财务部
public class FinanceDepartment implements Company {
    private String name = "";
    FinanceDepartment(String name) {
        this.name = name;
    }

    @Override
    public void addOrg(Company company) {
    }

    @Override
    public void removeOrg(Company company) {
    }

    @Override
    public void showOrg(int dept) {
        print(dept);
        System.out.println(this.name);
    }
}
// 人力资源部
public class HumanResourceDepartment implements Company {
    private String name = "";
    HumanResourceDepartment(String name) {
        this.name = name;
    }

    @Override
    public void addOrg(Company company) {
    }

    @Override
    public void removeOrg(Company company) {
    }

    @Override
    public void showOrg(int dept) {
        print(dept);
        System.out.println(this.name);
    }
}
// 测试类
public class After {
    public static void main(String[] args) {
        Company headquarters = new ConcreteComp("公司总部");
        headquarters.addOrg(new FinanceDepartment("财务部"));
        headquarters.addOrg(new HumanResourceDepartment("人力资源部"));

        Company gd = new ConcreteComp("广东分公司");
        gd.addOrg(new FinanceDepartment("财务部"));
        gd.addOrg(new HumanResourceDepartment("人力资源部"));

        Company sz = new ConcreteComp("深圳分公司");
        sz.addOrg(new FinanceDepartment("财务部"));
        sz.addOrg(new HumanResourceDepartment("人力资源部"));

        gd.addOrg(sz);

        Company sh = new ConcreteComp("上海分公司");
        sh.addOrg(new FinanceDepartment("财务部"));
        sh.addOrg(new HumanResourceDepartment("人力资源部"));

        headquarters.addOrg(gd);
        headquarters.addOrg(sh);

        headquarters.showOrg(1);

        Company test = new FinanceDepartment("测试财务部");
        test.addOrg(new HumanResourceDepartment("测试人力资源部"));
        test.addOrg(sh);

        test.showOrg(1);
    }
}

  1. 透明方式与安全方式

上面应用组合模式的方式就是透明方式，接口Company定义了addOrg、removeOrg方法，无论是叶子角色还是树枝角色都拥有addOrg、removeOrg方法，从实际使用的角度来说，叶子角色不需要这两个方法。对于外界来说，叶子和树枝的区别是透明的，这就是透明方式。

安全方式就是接口Company里没有定义addOrg、removeOrg方法，只在树枝角色添加addOrg、removeOrg方法。这样用户需要对叶子角色和树枝角色进行判断能不能使用ddOrg、removeOrg方法。

透明方式的缺点是叶子角色在添加叶子或者树枝时是什么也不做，用户觉得应该是操作成功了，但是并没有操作成功。安全方式的缺点就是在添加叶子和树枝的时候需要进行判断。

chuxuezhe_987
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
组合模式-五子棋代码.zip
12-23
在五子棋游戏的实现中，组合模式的应用尤为关键，因为它帮助我们将棋盘上的棋子和棋盘本身视为一个整体进行操作。 在Java设计模式中，组合模式通常包括以下几个主要组件： 1. **抽象组件（Component）**：定义了...
设计模式-组合模式-示例代码
最新发布
07-01
设计模式中的组合模式的示例代码。 包括透明写法和安全写法两种实现方式的示例。
离散：常用排列组合模型归纳，DFS代码实现
qq_44850917的博客
12-01 857
一、排列 1.定义 n个元素的集合A中任意选择r个（n≤rn\leq rn≤r）进行排列称为A的一个r-排列/r-Permutation n个元素的集合A的r-排列数为 $ p(n,r)=n(n-1)…1=n!/(n-r)!$ 2.理解 将n个元素选择r个元素出来（无顺序），然后进行全排列（有顺序）。 二、组合 1.定义 n个元素的集合A中任意选择r个（n≤rn\leq rn≤r）称为A的一个r-组合/r-Combination n个元素的集合A的r-组合数为 $ C(n,r)=n(n-1)…1/r!=n!
排列组合 - Java代码实现
热门推荐
To be a great coder
06-18 1万+
最近发现求排列组合在大公司的笔试算法题中经常作为比较重要的一步出现，所以写篇文章好好整理一下。 首先，回顾一下高中知识。。。排列组合的公式。 接下来对排列、组合分别给出 Java 代码的实现，而且每个部分都会给出两个方面的实现。 排列会先给出求全排列数量的代码实现，然后给出求全排列结果的代码实现。 组合会先给出求所有组合数量的代码实现，然后给出求所有组合结果的代码实现。   排列 &n...
JS实现的全排列组合算法示例
細水、長流√的专栏
02-28 871
全排列组合算法
Java 设计模式之组合模式
swadian2008的博客
04-13 1936
在 Java 组合模式中，抽象构件角色定义了所有叶子节点和容器节点共有的方法和属性，其中包括添加、移除子节点、获取子节点等方法。容器节点角色表示树形结构中的非叶子节点，它包含了其他的组合对象或叶子对象，可以用于组织和管理它所包含的子节点。定义容器构件（Composite）类，它是组合中的容器节点对象，它可以包含子节点，也可以有自己的方法和属性。在该类中通常包含一个用于存储子节点的容器。在客户端代码中使用组合模式构建对象树，通过调用容器节点的方法来增加、删除子节点，通过调用叶子节点的方法来访问节点数据。
好代码:如何优雅的实现数据的排列组合
yuanyuneixin1的专栏
11-21 228
优雅的实现数组元素的排列组合
设计模式代码实现0001
06-11
在这个"设计模式代码实现0001"的资源中，我们很可能会看到对各种经典设计模式的实际代码实现。 首先，设计模式分为三类：创建型、结构型和行为型。创建型模式关注对象的创建过程，如单例模式（Singleton）、工厂...
最简单的实现组合模式
02-19
在“最简单的实现组合模式”中，我们关注的是如何以最直观、最少依赖的方式体现这种模式的核心思想。 组合模式的核心概念是“部分-整体”的层次结构。它允许我们以一致的方式来处理单个对象（叶子节点）和由其他...
设计模式代码实现＋源码设计模式分析
02-16
在《设计模式代码实现》部分，我们将深入学习23种经典的GOF（GoF， Gamma, Helm, Johnson, Vlissides）设计模式，包括创建型模式（如单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式）、结构型模式（如...
排列组合源代码程序， 简单易懂
05-22
排列组合的源代码， 利用分治法和递归思想， 请大家点评~， Thanks
Java排列组合算法分析和代码实现
10-02
本资源附带文档解释了排列组合算法的实现和原理。其中排列算法是基于递归实现的，组合算法是基于高效的位移法实现的。代码是使用Java版实现的。
聚合和组合关系的代码体现
qq_49384528的博客
08-24 3089
*聚合和组合关系 * 聚合关系：雁群和大雁 * 组合关系：大雁和翅膀 * * 聚合关系和组合关系如何区分 * 看事物的紧密联系程度 用代码来体现：聚合 /*雁群*/ class YanQun{ private DaYan daYan; public YanQun(DaYan daYan){ this.daYan=daYan; } //脱离雁群 public void clearDaYan(){ this.daYan=null;...
UML关系与代码的映射
Wzill
07-21 590
UML关系和代码是一个一一对应的关系的，在我们写程序的时候，是需要先把UML图画出来的。图先行原则。根据画的UML图就可写出对应的代码。只要我们把UML图和关系弄明白了，写代码就不是问题了。下面给大家分享一下对于UML图中的关系和代码的一一映射关系。
排列与组合问题：映射方法
weixin_53350545的博客
12-11 542
组合数学自学思考
组合数个数的代码实现
weixin_53475254的博客
10-09 331
组合数公式 代码实现 明确数据类型 首先要先明确运算的数据类型。排列组合数是一组数字总共有多少种排列组合，所以运算的结果一定是整数。 记C(m, n)为从n个数中选取m个数，这些数无序有多少种不同的选法 记A(m, n)为从n个数中选取m个数，且这些数是有序的有多少种不同的选法 求解方法1：先求出分子分母如何做除法 public class Main { public static int arrayNumber(int m, int n){ if (m == 0) return
【设计模式】组合模式的实现--------Java
qq_45289396的博客
06-02 251
组合（Composite）模式 “数据结构”模式：常有一些组件在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，会破坏组件的复用性。这时，将这些特定的数据结构封装在内部，在外部提供统一的接口，来实现与特定数据结构无关的访问。 动机：将客户代码与复杂的对象容器结构解耦 组合模式的目的：不区分组合对象还是叶子对象，而是以一种统一的方式操作。 1.场景问题：（商品类别树） 包括：根节点、树枝节点、叶子节点 其中，根节点与树枝节点类似，都包含其他节点，成为容器节点。 package computer;
排列组合算法的代码实现——附Python源码
AI量化交易实验室
06-30 9037
一、问题描述 假设我们从数组[1,2,3,4,5,6]中，取出三个不重复的数，求所有可能的组合，数据不多，我们手动列举一下： 二、枚举法 看着几个三角形，是不是觉得很有规律，让人立刻想到是递归，但是递归式很容易让人混乱的算法，最简单的实现方法无疑是暴力枚举法，先写为敬，代码如下： def dd(): for i in range(1,7): for p in ...
组合模式树形结构代码
06-24
以下是一个简单的 Java 示例，使用组合模式实现一个树形结构（假设我们有一个抽象的 Component 类和具体实现的 Leaf 和 Composite 类）： ```java // 基础组件接口 interface Component { void operation(); } //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

chuxuezhe_987

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

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

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

打赏作者

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

抵扣说明：

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

余额充值