• 尚硅谷设计模式学习（十）组合模式

    以学校院系展示引出组合模式

    在一个页面中展示出学校的院系组成，一个学校有多个学院， 一个学院有多个系。如图：

    传统方案解决学校院系展示(类图) 

    问题分析

    1）将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的

    2）实际上我们的要求是 ：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等

    解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作。    =>   组合模式

    一、组合模式

    1、基本介绍

    组合模式，又称为部分与整体模式，将对象组合成树状结构以表示“整体-部分”的层次关系。

    组合模式依据树形结构来组合对象，用来表示部分以及整体层次，属于结构型模式

    组合模式使得用户对单个对象和组合对象的访问具有一致性，(即组合能让客户端以一致的方式处理个别对象以及组合对象)

     

    • Component：这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为，用于访问和管理 Component 子部件，Component可以是抽象类或者接口
    • Leaf：在组合中表示叶子节点，叶子节点没有子节点
    • Composite：非叶子节点，用于存储子部件，在  Component接口中实现子部件的相关操作，比如增加(add), 删除。 

    2、代码实现

    组织管理的抽象类

    1. public abstract class OrganizationComponent {
    2.     private String name;
    3.     //描述
    4.     private String description;
    5.  
    6.     //初始化
    7.     public OrganizationComponent(String name,String description){
    8.         this.name = name;
    9.         this.description = description;
    10.     }
    11.  
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     public void setName(String name) {
    17.         this.name = name;
    18.     }
    19.  
    20.     public String getDescription() {
    21.         return description;
    22.     }
    23.  
    24.     public void setDescription(String description) {
    25.         this.description = description;
    26.     }
    27.  
    28.     //输出打印方法; 大学,学院,院系都需要的;作为抽象方法;
    29.     protected abstract void print();
    30.  
    31.     //由于叶子节点可能不需要某些方法,所以就没用抽象方法，比如院系就不需要实现
    32.     //添加方法;
    33.     protected void add(OrganizationComponent organizationComponent){
    34.         throw new UnsupportedOperationException();
    35.     }
    36.  
    37.     //删除方法;
    38.     protected void remove(OrganizationComponent organizationComponent){
    39.         throw new UnsupportedOperationException();
    40.     }
    41. }

    大学类：作为 Composite 管理College(学院) 

    1. public class University extends OrganizationComponent{
    2.     //这里存放的是学院;
    3.     List organizationComponents = new ArrayList();
    4.  
    5.     public University(String name, String description) {
    6.         super(name, description);
    7.     }
    8.  
    9.     //添加方法
    10.     @Override
    11.     protected void add(OrganizationComponent organizationComponent) {
    12.         organizationComponents.add(organizationComponent);
    13.     }
    14.  
    15.     //删除方法
    16.     @Override
    17.     protected void remove(OrganizationComponent organizationComponent) {
    18.         organizationComponents.remove(organizationComponent);
    19.     }
    20.  
    21.     @Override
    22.     protected void print() {
    23.         System.out.println("-------------" + getName() + "------------------------");
    24.         for (OrganizationComponent organizationComponent : organizationComponents) {
    25.             organizationComponent.print();
    26.         }
    27.     }
    28. }

    学院类：管理院系 

    1. public class College extends OrganizationComponent{
    2.  
    3.     List organizationComponents = new ArrayList();
    4.  
    5.     public College(String name, String description) {
    6.         super(name, description);
    7.     }
    8.  
    9.     //添加方法
    10.     @Override
    11.     protected void add(OrganizationComponent organizationComponent) {
    12.         organizationComponents.add(organizationComponent);
    13.     }
    14.  
    15.     //删除方法
    16.     @Override
    17.     protected void remove(OrganizationComponent organizationComponent) {
    18.         organizationComponents.remove(organizationComponent);
    19.     }
    20.  
    21.     @Override
    22.     protected void print() {
    23.         System.out.println("-------------" + getName() + "------------------------");
    24.         for (OrganizationComponent organizationComponent : organizationComponents) {
    25.             organizationComponent.print();
    26.         }
    27.     }
    28. }

     院系类

    1. public class Department extends OrganizationComponent{
    2.  
    3.     public Department(String name, String description) {
    4.         super(name, description);
    5.     }
    6.  
    7.     @Override
    8.     protected void print() {
    9.         System.out.println(getName() + "   " + getDescription());
    10.     }
    11. }

     测试使用

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         OrganizationComponent university = new University("大学", "大学");
    4.  
    5.         OrganizationComponent computerCollege = new College("计算机学院", "计算机");
    6.         OrganizationComponent messageCollege = new College("信息与工程学院","信息与工程");
    7.  
    8.         computerCollege.add(new Department("软件工程","软件"));
    9.         computerCollege.add(new Department("计算机科学与技术","计算机科学与技术"));
    10.  
    11.         messageCollege.add(new Department("电子信息","电子信息"));
    12.         messageCollege.add(new Department("通信工程","通信工程"));
    13.  
    14.         university.add(computerCollege);
    15.         university.add(messageCollege);
    16.  
    17.         university.print();
    18.     }
    19. }

     结果

    -------------大学------------------------
    -------------计算机学院------------------------
    软件工程   软件
    计算机科学与技术   计算机科学与技术
    -------------信息与工程学院------------------------
    电子信息   电子信息
    通信工程   通信工程

    二、组合模式在 JDK 集合的源码分析

    Java 的集合类HashMap就使用了组合模式 

    进入Map接口查看，其中的put方法仅为抽象方法 

    1. public interface Map {
    2.  
    3.     V put(K key, V value);
    4.  
    5.     //......
    6.  
    7. }

    注意到Map接口的实现类AbstractMap是个抽象类，类似于组合模式的Component(抽象构建)

    其中重写 put 方法时，默认实现，抛出不支持操作的异常对象

    1. public abstract class AbstractMap implements Map {
    2.  
    3.     public V put(K var1, V var2) {
    4.         throw new UnsupportedOperationException();
    5.     }
    6.   
    7.     // ......
    8. }

    AbstractMap的子类HashMap，类似于组合模式的Composite(中间构建) 

    实现了 put方法，可以看到存入了Node节点中

    1. public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {
    2.  
    3.     public V put(K var1, V var2) {
    4.         return this.putVal(hash(var1), var1, var2, false, true);
    5.     }
    6.  
    7.     final V putVal(int var1, K var2, V var3, boolean var4, boolean var5) {
    8.         HashMap.Node[] var6;
    9.         int var8;
    10.         if ((var6 = this.table) == null || (var8 = var6.length) == 0) {
    11.             var8 = (var6 = this.resize()).length;
    12.         }
    13.  
    14.         Object var7;
    15.         int var9;
    16.         if ((var7 = var6[var9 = var8 - 1 & var1]) == null) {
    17.             var6[var9] = this.newNode(var1, var2, var3, (HashMap.Node)null);
    18.         } else {
    19.             Object var10;
    20.             Object var11;
    21.             if (((HashMap.Node)var7).hash == var1 && ((var11 = ((HashMap.Node)var7).key) == var2 || var2 != null && var2.equals(var11))) {
    22.                 var10 = var7;
    23.             } else if (var7 instanceof HashMap.TreeNode) {
    24.                 var10 = ((HashMap.TreeNode)var7).putTreeVal(this, var6, var1, var2, var3);
    25.             } else {
    26.                 int var12 = 0;
    27.  
    28.                 while(true) {
    29.                     if ((var10 = ((HashMap.Node)var7).next) == null) {
    30.                         ((HashMap.Node)var7).next = this.newNode(var1, var2, var3, (HashMap.Node)null);
    31.                         if (var12 >= 7) {
    32.                             this.treeifyBin(var6, var1);
    33.                         }
    34.                         break;
    35.                     }
    36.  
    37.                     if (((HashMap.Node)var10).hash == var1 && ((var11 = ((HashMap.Node)var10).key) == var2 || var2 != null && var2.equals(var11))) {
    38.                         break;
    39.                     }
    40.  
    41.                     var7 = var10;
    42.                     ++var12;
    43.                 }
    44.             }
    45.  
    46.     //......
    47. }

     Node类似于组合模式的叶子节点 Leaf

    1.     static class Node implements Entry {
    2.         final int hash;
    3.         final K key;
    4.         V value;
    5.         HashMap.Node next;
    6.  
    7.         Node(int var1, K var2, V var3, HashMap.Node var4) {
    8.             this.hash = var1;
    9.             this.key = var2;
    10.             this.value = var3;
    11.             this.next = var4;
    12.         }
    13.  
    14.         public final K getKey() {
    15.             return this.key;
    16.         }
    17.  
    18.         public final V getValue() {
    19.             return this.value;
    20.         }
    21.  
    22.         public final String toString() {
    23.             return this.key + "=" + this.value;
    24.         }
    25.  
    26.         public final int hashCode() {
    27.             return Objects.hashCode(this.key) ^ Objects.hashCode(this.value);
    28.         }
    29.  
    30.         public final V setValue(V var1) {
    31.             Object var2 = this.value;
    32.             this.value = var1;
    33.             return var2;
    34.         }
    35.  
    36.         public final boolean equals(Object var1) {
    37.             if (var1 == this) {
    38.                 return true;
    39.             } else {
    40.                 if (var1 instanceof Entry) {
    41.                     Entry var2 = (Entry)var1;
    42.                     if (Objects.equals(this.key, var2.getKey()) && Objects.equals(this.value, var2.getValue())) {
    43.                         return true;
    44.                     }
    45.                 }
    46.  
    47.                 return false;
    48.             }
    49.         }
    50.     }

    三、组合模式的注意事项和细节

    1）简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。

    2）具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动。

    3）方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构

    4）需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式。

    5）要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式 

  • 相关阅读:
    spark-submit 高频可选参数及作用
    深度学习实战53-行业描述分类的实战应用:基于ALBERT模型和PyTorch框架的解析
    数据结构小记【Python/C++版】——栈篇
    二叉搜索树的本质
    用frp搞个内网穿透
    [机缘参悟-119] ：一个IT人的反思：反者道之动；弱者，道之用 VS 恒者恒强，弱者恒弱的马太效应
    2022CCPC预选赛C Guess(博弈)
    python发送邮件
    RPA技术介绍与应用价值
    ajax笔记二
  • 原文地址：https://blog.csdn.net/qq_51409098/article/details/126903252