登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›【组合设计模式详解】C/Java/JS/Go/Python/TS不同语言实 ...

【组合设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

訾懵 2025-6-6 09:40:45
简介

组合模式（Composite Pattern），又叫部分整体模式，是一种结构型设计模式。用于把一组类似的对象当作一个单一的对象来看。组合模式依据树形结构来组合对象，用不同组件来构建某个部分或整体对象。
如果你需要实现树状对象结构，可以使用组合模式。如果你希望客户端代码以相同方式处理简单和复杂元素，可以使用该模式。
作用


  • 符合开闭原则。无需更改现有代码，就可以在应用中添加新元素，使之成为对象树的一部分。
  • 模糊了简单元素和复杂元素的概念，程序可以像处理简单元素一样来处理复杂元素，从而使得程序与复杂元素的内部结构解耦。
实现步骤


  • 创建抽象构件（Component）接口，用于声明树叶构件和树枝构件的默认行为。
  • 创建树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。
  • 定义树叶构件（Leaf）角色：是组合中的叶子节点对象，它没有子节点，用于继承或实现抽象构件。
UML

1.png


 
Java语言代码

基础部件接口
  1. // OrganizationComponent.java 定义部件接口或抽象类，分支和叶子节点遵循该类约定
  2. public interface OrganizationComponent {
  3.    public void add(OrganizationComponent component);
  5.    public void remove(OrganizationComponent component);
  7.    public OrganizationComponent getChild(int index);
  9.    public void operation();
  11.    public String getName();
  12. }
复制代码
 
具体部件实现
  1. // CompanyComposite.java 实现部件的树枝构件1
  2. public class CompanyComposite implements OrganizationComponent {
  4.    private String name;
  5.    private List<OrganizationComponent> children = new ArrayList<OrganizationComponent>();
  7.    public CompanyComposite(String name) {
  8.       this.name = name;
  9.    }
  11.    public void add(OrganizationComponent component) {
  12.       children.add(component);
  13.    }
  15.    public void remove(OrganizationComponent component) {
  16.       children.remove(component);
  17.    }
  19.    public OrganizationComponent getChild(int index) {
  20.       return children.get(index);
  21.    }
  23.    public void operation() {
  24.       System.out.println(this.getClass().getName() + " CompanyComposite::operation() " + this.name);
  25.       for (Object component : children) {
  26.          ((OrganizationComponent) component).operation();
  27.       }
  28.    }
  30.    public String getName() {
  31.       return name;
  32.    }
  33. }<br>
  34. // DepartmentComposite.java  实现部件的树枝构件2
  35. public class DepartmentComposite implements OrganizationComponent {
  37.    private String name;
  38.    private List<OrganizationComponent> children = new ArrayList<OrganizationComponent>();
  40.    public DepartmentComposite(String name) {
  41.       this.name = name;
  42.    }
  44.    public void add(OrganizationComponent component) {
  45.       children.add(component);
  46.    }
  48.    public void remove(OrganizationComponent component) {
  49.       children.remove(component);
  50.    }
  52.    public OrganizationComponent getChild(int index) {
  53.       return children.get(index);
  54.    }
  56.    public void operation() {
  57.       System.out.println(this.getClass().getName() + " DepartmentComposite::operation() " + this.name);
  58.       for (Object component : children) {
  59.          ((OrganizationComponent) component).operation();
  60.       }
  61.    }
  63.    public String getName() {
  64.       return name;
  65.    }
  66. }<br>
  67. // EmployeeLeaf.java 实现部件的叶子节点，叶子节点不能再含有子节点
  68. public class EmployeeLeaf implements OrganizationComponent {
  70.    private String name;
  72.    public EmployeeLeaf(String name) {
  73.       this.name = name;
  74.    }
  76.    // 叶子节点不能再增加内容
  77.    public void add(OrganizationComponent component) {
  78.       System.out.println("Leaf can't add.");
  79.    }
  81.    // 叶子节点没有移除内容
  82.    public void remove(OrganizationComponent component) {
  83.       System.out.println("Leaf can't remove.");
  84.    }
  86.    // 叶子节点无获取子节点
  87.    public OrganizationComponent getChild(int index) {
  88.       System.out.println("Leaf can't getChild.");
  89.       return null;
  90.    }
  92.    public void operation() {
  93.       System.out.println(this.getClass().getName() + " EmployeeLeaf::operation() " + this.name);
  94.    }
  96.    public String getName() {
  97.       return name;
  98.    }
  99. }
复制代码
 
测试调用
  1.     /**
  2.      * 组合模式依据树形结构来组合对象，用不同组件来构建整体对象。
  3.      * 不同组件之间有相同的接口约束，有不同的具体实现。
  4.      * 先定义顶级节点，然后陆续加入枝叶节点和叶子节点，这样不断添加，将零散的个体组成一个整体。
  5.      */
  7.     // 通过组合模型组合了一个部件，分支和节点可以随意增删
  8.     OrganizationComponent com = new CompanyComposite("西天旅游有限公司");
  9.     OrganizationComponent com1 = new DepartmentComposite("总裁办");
  10.     OrganizationComponent com2 = new DepartmentComposite("行动队");
  11.     OrganizationComponent com3 = new DepartmentComposite("后勤组");
  12.     OrganizationComponent leaf1 = new EmployeeLeaf("唐三藏");
  13.     OrganizationComponent leaf2 = new EmployeeLeaf("孙悟空");
  14.     OrganizationComponent leaf3 = new EmployeeLeaf("猪悟能");
  15.     OrganizationComponent leaf4 = new EmployeeLeaf("沙悟净");
  17.     com.add(com1);
  18.     com.add(com2);
  19.     com.add(com3);
  21.     // leaf1属于com1
  22.     com1.add(leaf1);
  23.     // leaf2, leaf3属于com2
  24.     com2.add(leaf2);
  25.     com2.add(leaf3);
  27.     // 添加再删除
  28.     DepartmentComposite dept1 = new DepartmentComposite("小分队");
  29.     com2.add(dept1);
  30.     EmployeeLeaf tmp1 = new EmployeeLeaf("临时工");
  31.     dept1.add(tmp1);
  32.     dept1.remove(tmp1);
  34.     // leaf4属于com3
  35.     com3.add(leaf4);
  37.     // 执行全部节点动作
  38.     com.operation();
  40.     // 获取某个节点
  41.     OrganizationComponent employee = (EmployeeLeaf) com.getChild(1).getChild(0);
  42.     System.out.println(employee.getName());
复制代码
 
C语言代码
  1. func.h 自定义头文件
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <stdbool.h>
  5. #include <string.h>
  7. // 定义部件接口或抽象类，分支和叶子节点遵循该类约定
  8. typedef struct OrganizationComponent
  9. {
  10.     char name[200];
  11.     void (*add)(struct OrganizationComponent *, struct OrganizationComponent *);
  12.     void (*remove)(struct OrganizationComponent *, struct OrganizationComponent *);
  13.     struct OrganizationComponent *(*get_child)(struct OrganizationComponent *, int);
  14.     void (*operation)(struct OrganizationComponent *);
  15.     int children_size;
  16.     struct OrganizationComponent **children;
  17.     // 如果是柔型数组，则自动扩展数组长度，但可能导致出现乱码现象，故采取固定长度数组
  18.     // struct OrganizationComponent *children[];
  19. } OrganizationComponent;
  20. void add_component(OrganizationComponent *, OrganizationComponent *);
  21. void remove_component(OrganizationComponent *, OrganizationComponent *);
  22. OrganizationComponent *get_child_component(OrganizationComponent *, int);
  23. void print_children(OrganizationComponent *children[], int children_size);
  25. // 实现部件的树枝构件1
  26. typedef struct CompanyComposite
  27. {
  28.     char name[200];
  29.     void (*add)(struct OrganizationComponent *, struct OrganizationComponent *);
  30.     void (*remove)(struct OrganizationComponent *, struct OrganizationComponent *);
  31.     struct OrganizationComponent *(*get_child)(struct OrganizationComponent *, int);
  32.     void (*operation)(struct CompanyComposite *);
  33.     int children_size;
  34.     struct OrganizationComponent **children;
  35. } CompanyComposite;
  36. CompanyComposite *company_composite_constructor(char *name);
  38. // 实现部件的树枝构件2
  39. typedef struct DepartmentComposite
  40. {
  41.     char name[200];
  42.     void (*add)(struct OrganizationComponent *, struct OrganizationComponent *);
  43.     void (*remove)(struct OrganizationComponent *, struct OrganizationComponent *);
  44.     struct OrganizationComponent *(*get_child)(struct OrganizationComponent *, int);
  45.     void (*operation)(struct DepartmentComposite *);
  46.     int children_size;
  47.     struct OrganizationComponent **children;
  48. } DepartmentComposite;
  49. DepartmentComposite *department_composite_constructor(char *name);
  51. // 实现部件的叶子节点，叶子节点不能再含有子节点
  52. typedef struct EmployeeLeaf
  53. {
  54.     char name[200];
  55.     void (*add)(struct OrganizationComponent *, struct OrganizationComponent *);
  56.     void (*remove)(struct OrganizationComponent *, struct OrganizationComponent *);
  57.     struct OrganizationComponent *(*get_child)(struct OrganizationComponent *, int);
  58.     void (*operation)(struct EmployeeLeaf *);
  59.     int children_size;
  60.     struct OrganizationComponent **children;
  61. } EmployeeLeaf;
  62. EmployeeLeaf *employee_leaf_constructor(char *name);
复制代码
 
基础部件接口
  1. // organization_component.c 定义部件接口或抽象类，分支和叶子节点遵循该类约定
  2. #include "func.h"
  4. // 定义部件接口或抽象类，分支和叶子节点遵循该类约定
  5. // C语言没有接口和抽象类，用struct替代，同时把公共函数声明在这里
  7. // 添加一个组件到子节点中
  8. void add_component(OrganizationComponent *parent, OrganizationComponent *component)
  9. {
  10.   // 先将原数组保留下来
  11.   OrganizationComponent **old_children = parent->children;
  12.   parent->children_size += 1;
  13.   // 新申请空间给子节点数组
  14.   parent->children = (OrganizationComponent **)calloc(parent->children_size, sizeof(OrganizationComponent *));
  15.   for (int i = 0; i < parent->children_size - 1; i++)
  16.   {
  17.     parent->children[i] = old_children[i];
  18.   }
  19.   // 将组件追加到子节点数组中
  20.   parent->children[parent->children_size - 1] = component;
  21.   free(old_children);
  22. }
  24. // 移除第一个匹配的子节点
  25. void remove_component(OrganizationComponent *parent, OrganizationComponent *component)
  26. {
  27.   int size = parent->children_size;
  28.   // 初始化组件id大于数组长度
  29.   int com_idx = size;
  30.   for (int i = 0; i < size; i++)
  31.   {
  32.     // 找到第一个匹配的组件下标
  33.     if (parent->children[i] == component)
  34.     {
  35.       com_idx = i;
  36.     }
  38.     // 自匹配项开始，后项逐个往前移动1位
  39.     if (i >= com_idx)
  40.     {
  41.       parent->children[i] = parent->children[i + 1];
  42.       // 最后一项置空且总长度减少1位
  43.       if (i == size - 1)
  44.       {
  45.         parent->children[i] = NULL;
  46.         parent->children_size -= 1;
  47.       }
  48.     }
  49.   }
  50. }
  52. // 打印全部子节点
  53. void print_children(OrganizationComponent *children[], int children_size)
  54. {
  55.   for (int i = 0; i < children_size; i++)
  56.   {
  57.     printf("\r\n    children[%d]=%s", i, children[i]->name);
  58.   }
  59. }
  61. // 根据下标获取子节点
  62. OrganizationComponent *get_child_component(OrganizationComponent *component, int index)
  63. {
  64.   return component->children[index];
  65. }
复制代码
 
具体部件实现
  1. // company_composite.c 实现部件的树枝构件1
  2. #include "func.h"
  4. // 实现部件的树枝构件1
  5. void company_composite_operation(CompanyComposite *component)
  6. {
  7.   printf("\r\n CompanyComposite::operation() [name=%s]", component->name);
  8.   print_children(component->children, component->children_size);
  9.   for (int i = 0; i < component->children_size; i++)
  10.   {
  11.     if (component->children[i] != NULL)
  12.     {
  13.       component->children[i]->operation(component->children[i]);
  14.     }
  15.   }
  16. }
  18. // 创建CompanyComposite对象
  19. CompanyComposite *company_composite_constructor(char *name)
  20. {
  21.   OrganizationComponent *component = (OrganizationComponent *)malloc(sizeof(OrganizationComponent));
  22.   strncpy(component->name, name, 200);
  23.   component->add = &add_component;
  24.   component->remove = &remove_component;
  25.   component->children_size = 0;
  26.   component->get_child = &get_child_component;
  27.   // 转为CompanyComposite
  28.   CompanyComposite *company_composite = (CompanyComposite *)component;
  29.   company_composite->operation = &company_composite_operation;
  30.   return company_composite;
  31. }<br><br>
  32. // department_composite.c  实现部件的树枝构件2
  33. #include "func.h"
  35. // 实现部件的树枝构件2
  36. void department_composite_operation(DepartmentComposite *component)
  37. {
  38.   printf("\r\n DepartmentComposite::operation() [name=%s]", component->name);
  39.   print_children(component->children, component->children_size);
  40.   for (int i = 0; i < component->children_size; i++)
  41.   {
  42.     if (component->children[i] != NULL)
  43.     {
  44.       component->children[i]->operation(component->children[i]);
  45.     }
  46.   }
  47. }
  49. // 创建DepartmentComposite对象
  50. DepartmentComposite *department_composite_constructor(char *name)
  51. {
  52.   OrganizationComponent *component = (OrganizationComponent *)malloc(sizeof(OrganizationComponent));
  53.   strncpy(component->name, name, 200);
  54.   component->add = &add_component;
  55.   component->remove = &remove_component;
  56.   component->children_size = 0;
  57.   component->get_child = &get_child_component;
  58.   // 转为DepartmentComposite
  59.   DepartmentComposite *department_composite = (DepartmentComposite *)component;
  60.   department_composite->operation = &department_composite_operation;
  61.   return department_composite;
  62. }<br><br>
  63. // employee_leaf.c 实现部件的叶子节点，叶子节点不能再含有子节点
  64. #include "func.h"
  66. // 实现部件的叶子节点，叶子节点不能再含有子节点
  68. // 叶子节点不能再增加内容
  69. void add_leaf_component(OrganizationComponent *parent, OrganizationComponent *component)
  70. {
  71.   printf("\r\n Leaf can't add.");
  72. }
  74. // 叶子节点没有移除内容
  75. void remove_leaf_component(OrganizationComponent *parent, OrganizationComponent *component)
  76. {
  77.   printf("\r\n Leaf can't remove.");
  78. }
  80. // 叶子节点不能获取子节点
  81. OrganizationComponent *get_leaf_child_component(OrganizationComponent *component, int index)
  82. {
  83.   printf("\r\n Leaf can't get_child.");
  84.   return NULL;
  85. }
  87. // 子节点的操作函数
  88. void employee_leaf_operation(EmployeeLeaf *component)
  89. {
  90.   printf("\r\n EmployeeLeaf::operation() [name=%s]", component->name);
  91. }
  93. // 创建EmployeeLeaf对象
  94. EmployeeLeaf *employee_leaf_constructor(char *name)
  95. {
  96.   OrganizationComponent *component = (OrganizationComponent *)malloc(sizeof(OrganizationComponent));
  97.   strncpy(component->name, name, 200);
  98.   component->children_size = 0;
  99.   component->add = &add_leaf_component;
  100.   component->remove = &remove_leaf_component;
  101.   component->get_child = &get_leaf_child_component;
  102.   // 转为EmployeeLeaf
  103.   EmployeeLeaf *employee_leaf = (EmployeeLeaf *)component;
  104.   employee_leaf->operation = &employee_leaf_operation;
  105.   return employee_leaf;
  106. }
复制代码
 
测试调用
  1.    /**
  2.     * 组合模式依据树形结构来组合对象，用不同组件来构建整体对象。
  3.     * 不同组件之间有相同的接口约束，有不同的具体实现。
  4.     * 先定义顶级节点，然后陆续加入枝叶节点和叶子节点，这样不断添加，将零散的个体组成一个整体。ss
  5.     */
  7.    // 通过组合模型组合了一个部件，分支和节点可以随意增删
  8.    OrganizationComponent *com = (OrganizationComponent *)company_composite_constructor("西天旅游有限公司");
  9.    OrganizationComponent *com1 = (OrganizationComponent *)department_composite_constructor("总裁办");
  10.    OrganizationComponent *com2 = (OrganizationComponent *)department_composite_constructor("行动队");
  11.    OrganizationComponent *com3 = (OrganizationComponent *)department_composite_constructor("后勤组");
  13.    OrganizationComponent *leaf1 = (OrganizationComponent *)employee_leaf_constructor("唐三藏");
  14.    OrganizationComponent *leaf2 = (OrganizationComponent *)employee_leaf_constructor("孙悟空");
  15.    OrganizationComponent *leaf3 = (OrganizationComponent *)employee_leaf_constructor("猪悟能");
  16.    OrganizationComponent *leaf4 = (OrganizationComponent *)employee_leaf_constructor("沙悟净");
  18.    com->add(com, com1);
  19.    com->add(com, com2);
  20.    com->add(com, com3);
  22.    // leaf1属于com1
  23.    com1->add(com1, leaf1);
  24.    // leaf2, leaf3属于com2
  25.    com2->add(com2, leaf2);
  26.    com2->add(com2, leaf3);
  28.    // 添加再删除
  29.    DepartmentComposite *dept1 = department_composite_constructor("小分队");
  30.    com2->add(com2, (OrganizationComponent *)dept1);
  31.    EmployeeLeaf *tmp1 = employee_leaf_constructor("临时工");
  32.    dept1->add((OrganizationComponent *)dept1, (OrganizationComponent *)tmp1);
  33.    dept1->remove((OrganizationComponent *)dept1, (OrganizationComponent *)tmp1);
  35.    // leaf4属于com3
  36.    com3->add(com3, leaf4);
  38.    // 执行全部节点动作
  39.    com->operation(com);
  41.    // 获取某个节点
  42.    OrganizationComponent *dept2 = com->get_child(com, 1);
  43.    EmployeeLeaf *employee_child1 = (EmployeeLeaf *)dept2->get_child(dept2, 0);
  44.    printf("\r\n [employee->name=%s]", employee_child1->name);
复制代码
 
更多语言版本

不同语言实现设计模式源码，请查看：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
组合设计模式详解JavaJS

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
訾懵
2025-6-6 09:40:45

0

粉丝关注

20

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫