Java 设计模式——组合模式

转x33g5p2x  于2022-02-12 转载在 Java  
字(7.7k)|赞(0)|评价(0)|浏览(396)

概述

有时我们可能会被要求处理一个层级结构明显的对象，比如上下级的公司员工、比如层级嵌套的文件夹，还有丰富多彩的美食菜单。可是，我们可能要屡试不爽地编写深度搜索代码、要小心翼翼地编写递归逻辑。现在你可以忘掉这些，学习一些新的技能，让你秒刷副本。当然，这句有些夸张，你可以忽略。只是它单纯地表达我对本文要说的这个模式的喜欢（也有可能只是因为我工作中恰好遇到这个问题）。

组合模式

定义

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

情境分析

看到组合的模式的定义，或许你就知道了这里的组合与我们平常讨论的*“继承-组合”*并不是同一个概念。因为在学习组合模式之前，我就是把这两个弄得有点混淆，所以一直没有认真地学习过它，以为组合也就是那么回事了嘛。可是，当我开始真的学习它的时候，才知道，这是两回事。
定义上说的是部分与整体的层次结构，可能就这前半句还不能说明什么，不过我们可以从后半句中找到突破点，那就是单个对象与组合对象。也就是在组合对象中组合了一个部分的集合，这个集合中的元素也就是单个元素所具有的对象类型。
当然，你不要理解成组合模式里也可以只有这个集合了。如果是这样，那么一个 List 完全可以可以搞定，又何必搞出个模式来突显逼格呢？
现在我们就来“举个栗子”，对，是栗子。哈哈~
我现在是一家中式餐厅的老板了。在我的店里你可以享用早餐、中餐、晚餐。早餐就简单点，只提供包子、油条跟豆浆吧（是的，这个不是主业）。午餐会丰盛一些，在午餐里你们选择北方菜或是南方菜。北方菜主要有：锅包肉、猪肉炖粉条、辣子鸡、干炸里脊、糖醋里脊、板栗烧鸡、地三鲜、红烧肉、回锅肉、 口水鸡、宫保鸡丁、可乐鸡翅；南方菜主要有：炒米粉、南瓜饼、南焖羊肉、蒸排骨、肉片炒青椒、水果皮萨、北炒鱼香茄子、糯米糍团、芥菜煲。晚餐上可以吃得精致一些，主要有地道小吃和甜点。地道小吃：肉夹馍、羊肉泡馍、乌冬面、章鱼小丸子、葱油饼、老婆饼；甜点：冰淇淋、鲜奶蛋糕还有蜜汁藕。
把上面的描述转换成图片菜单就像下面这样的：

当然，这里并不够齐全，只是为了照顾图片的大小（当然也不可否认是博主偷懒了），只绘制了其中的一部分，不过足够我们说明问题了。

一般组合模式

模式分析

在一般组合模式里，我们只做了一件事，那就是模糊了简单元素与复杂元素。怎么说明这一点呢？针对上面举的例子来说，我们的每一种菜都是一个简单元素，而每一种菜系（南方/北方/小说/甜点）或是餐饮的类型（早餐/午餐/晚餐）都是一个复杂元素，因为这里又包含若干的简单元素。我们把菜系定义为 Menu，而每一道具体的菜则定义成 MenuItem。这样我们就可以绘制出一般组合模式的类图，如下：

这里面我们的菜单（Menu）和菜单项（MenuItem）都继承自一个 MenuComponent。MenuComponent 是一个抽象的类。当 Menu 和 MenuItem 继承自同一个类时，我们就可以实现模糊简单元素与复杂元素了，因为我们可以按照处理 MenuComponent 的方式处理 Menu 和 MenuItem。这里我们只是模糊了这两个的分界，却不能真的等同看待。很简单，上面的的 MenuItem 最起码有一个价格的属性、而 Menu 就不存在这个属性；Menu 可以有一个 add MenuComponent 的方法，而 MenuItem 则不可能会有。
说到这里，可能你会说组合模式并不完美。是的，我也这么觉得。它让这件事情模糊了，让 MenuComponent 的使用产生了歧义。比如我们在使用它的时候，根本不知道它的某一个方法是可以正常使用。比如，一个 MenuComponent（可实际的类型可能是 Menu，而我们不知道），这时可能会调用它的 getPrice() 方法，这是有问题的，逻辑上是走不通的。那么，我们就必须要为 Menu 的这个方法抛出一个异常（异常是一个心机 boy，我们都不太喜欢它）。当然，也可以在外部使用 instanceof 关键字处理。可是，这样的处理总让我有一种非面向对象的处理过程，所以还是抛出异常吧。
另外，Menu 中组合了 MenuItem，从这一点来看，倒是有几分“继承-组合”的意味。

逻辑实现

先来看看抽象类，这个是基础：
MenuComponent.java

  1. public abstract class MenuComponent {
  2.  
  3.     public String getName() {
  4.         throw new UnsupportedOperationException("暂不支持此操作");
  5.     }
  6.  
  7.     public String getDescription() {
  8.         throw new UnsupportedOperationException("暂不支持此操作");
  9.     }
  10.  
  11.     public double getPrice() {
  12.         throw new UnsupportedOperationException("暂不支持此操作");
  13.     }
  14.  
  15.     public boolean isVegetarian() {
  16.         throw new UnsupportedOperationException("暂不支持此操作");
  17.     }
  18.  
  19.     public void print() {
  20.         throw new UnsupportedOperationException("暂不支持此操作");
  21.     }
  22.  
  23.     public void add(MenuComponent menuComponent) {
  24.         throw new UnsupportedOperationException("暂不支持此操作");
  25.     }
  26.  
  27.     public void remove(MenuComponent menuComponent) {
  28.         throw new UnsupportedOperationException("暂不支持此操作");
  29.     }
  30.  
  31.     public MenuComponent getChild(int childIndex) {
  32.         throw new UnsupportedOperationException("暂不支持此操作");
  33.     }
  34. }

而在 Menu 的具体类中，虽然是继承了 MenuComponent，可是它的抽象方法又不能全部重写。原因上面也说了，这里不赘述了。可是，由于 Java 语法的客观存在，所以这里我们抛出了一个异常。
Menu.java

  1. public class Menu extends MenuComponent {
  2.  
  3.     private String name = null;
  4.     private String desc = null;
  5.     private List<MenuComponent> menuComponents = null;
  6.  
  7.     public Menu(String _name, String _desc) {
  8.         name = _name;
  9.         desc = _desc;
  10.     }
  11.  
  12.     @Override
  13.     public String getName() {
  14.         return name;
  15.     }
  16.  
  17.     @Override
  18.     public String getDescription() {
  19.         return desc;
  20.     }
  21.  
  22.     @Override
  23.     public void print() {
  24.         System.out.println("\nMenu: { " + name + ", " + desc + " }");
  25.         if (menuComponents == null) {
  26.             return;
  27.         }
  28.         System.out.println("-------------------------");
  29.  
  30.         for (MenuComponent menuComponent : menuComponents) {
  31.             menuComponent.print();
  32.         }
  33.     }
  34.  
  35.     @Override
  36.     public void add(MenuComponent menuComponent) {
  37.         if (menuComponents == null) {
  38.             menuComponents = new ArrayList<MenuComponent>();
  39.         }
  40.         menuComponents.add(menuComponent);
  41.     }
  42.  
  43.     @Override
  44.     public MenuComponent getChild(int childIndex) {
  45.         if (menuComponents == null || menuComponents.size() <= childIndex) {
  46.             return null;
  47.         }
  48.         return menuComponents.get(childIndex);
  49.     }
  50. }

基于上面对 Menu 类的说明，这里的 MenuItem 类的实现过程也是一样：只重写能够重写的部分，不能重写的地方抛出一个异常等待上层处理。
MenuItem.java

  1. public class MenuItem extends MenuComponent {
  2.  
  3.     private String name = null;
  4.     private String desc = null;
  5.     private boolean vegetarian = false;
  6.     private double price = 0.0d;
  7.  
  8.     public MenuItem(String _name, String _desc, boolean _vegetarian, double _price) {
  9.         this.name = _name;
  10.         this.desc = _desc;
  11.         this.vegetarian = _vegetarian;
  12.         this.price = _price;
  13.     }
  14.  
  15.     @Override
  16.     public String getName() {
  17.         return name;
  18.     }
  19.  
  20.     @Override
  21.     public String getDescription() {
  22.         return desc;
  23.     }
  24.  
  25.     @Override
  26.     public double getPrice() {
  27.         return price;
  28.     }
  29.  
  30.     @Override
  31.     public boolean isVegetarian() {
  32.         return vegetarian;
  33.     }
  34.  
  35.     @Override
  36.     public void print() {
  37.         System.out.println("MenuItem: { " + name + ", " + desc + ", " + vegetarian + ", " + price + " }");
  38.     }
  39. }

上面的代码是整个一般组合模式的关键部分，这是需要注意的是它们的 print() 方法。对于 MenuItem 的 print() 来说，是很常规的打印，而 Menu 的打印则需要作处理。因为我们正常的理解里一个菜单因为会包含很多菜单项，所以，这里我们就把当前菜单下的所以菜单打印一遍。不过，这也不是什么难事，因为在每份 Menu 中都有一个 MenuItem 的列表。好了，问题解决。详情参见上面的代码部分。

模式小结

从上面的例子也可以看出，组合模式在解决有层级关系时，有着得天独厚的优势。思路清晰、代码优雅。唯一的不足是我们要针对不同的情况抛出相应的异常。

组合与迭代

对于组合模式息息相关的另一种模式——迭代模式，它在组合模式中可以说有着重要的地位。在上面的代码中，有点编程逻辑的人应该都可以发现，它们的 print() 方法是对象内部的操作。也就是说，如果我想要通过一个 Menu 操作一个 MenuItem 就必须在 Menu 内部进行实现。这是不现实的，因为需求变化的速度，可能隔了几秒连它的亲妈也不认识了。正因为如此，所以我们就必须想办法从外部拿到 Menu 中的 MenuItem。
比如现在我想知道餐厅里所有的素食有哪些，如果我们不去改动原有代码，那么就可以添加一个外部的迭代逻辑。

深搜的试水之行

或许你又会说，这里根本不需要使用迭代，用一次深搜就 OK 了。是的没错，而且对于一个数据结构基本功还可以的同学，可以马上写出一个深搜的解决方案。这里给出我的深搜方案：

  1. public void showVegetarMenu(MenuComponent menu) {
  2.         List<MenuComponent> visited = new ArrayList<>();
  3.         showVegetarMenu(menu, visited);
  4.     }
  5.  
  6.     private void showVegetarMenu(MenuComponent menu, List<MenuComponent> visited) {
  7.         if (visited.contains(menu)) {
  8.             return;
  9.         }
  10.  
  11.         if (menu instanceof MenuItem) {
  12.             if (menu.isVegetarian()) {
  13.                 System.out.println(menu);
  14.             }
  15.             return;
  16.         }
  17.  
  18.         List<MenuComponent> children = ((Menu) menu).getChildren();
  19.         for (int i = 0; i < children.size(); i++) {
  20.             showVegetarMenu(children.get(i), visited);
  21.         }
  22.     }

结果不出意外。能够使用深搜，已然是逼格满满了。不过，使用深搜让我有一种面向过程编程的感觉，不够优雅。下面就让我用迭代器来实现一次华丽的逆转吧。

迭代的逆转

首先我们为 MenuComponent 添加一个 createIterator() 方法。就像下面这样：
MenuComponent.java

  1. public abstract class MenuComponent {
  2.  
  3.     ( ... 省略重复的 N 条  ... )
  4.  
  5.     public abstract Iterator<MenuComponent> createIterator();
  6. }

由于这里添加的是一个抽象的方法，那么在 Menu 和 MenuItem 中就要必须重写这个 createIterator() 方法。
Menu.java

  1. public class Menu extends MenuComponent {
  2.  
  3.     private CompositeIterator iterator = null;
  4.  
  5.     ( ... 省略重复的 N 条  ... )
  6.  
  7.     @Override
  8.     public Iterator<MenuComponent> createIterator() {
  9.         if (iterator == null) {
  10.             iterator = new CompositeIterator(menuComponents.iterator());
  11.         }
  12.  
  13.         return iterator;
  14.     }
  15. }

MenuItem.java

  1. public class MenuItem extends MenuComponent {
  2.  
  3.     ( ... 省略重复的 N 条  ... )
  4.  
  5.     @Override
  6.     public Iterator<MenuComponent> createIterator() {
  7.         return new NullIterator();
  8.     }
  9. }

在上面两段代码中提到了两个迭代器类：CompositeIterator、NullIterator。这里有参照书本上的逻辑，不过也有改动，因为书本的迭代器没有通用性，下面会对这一点进行说明的。
CompositeIterator.java

  1. public class CompositeIterator implements Iterator<MenuComponent> {
  2.  
  3.     private Stack<Iterator> stack = new Stack<>();
  4.  
  5.     public CompositeIterator(Iterator iterator) {
  6.         stack.push(iterator);
  7.     }
  8.  
  9.     @Override
  10.     public boolean hasNext() {
  11.         if (stack.empty()) {
  12.             return false;
  13.         }
  14.  
  15.         Iterator iterator = stack.peek();
  16.         if (!iterator.hasNext()) {
  17.             stack.pop();
  18.             return hasNext();
  19.         }
  20.  
  21.         return true;
  22.     }
  23.  
  24.     @Override
  25.     public MenuComponent next() {
  26.         if (hasNext()) {
  27.             Iterator iterator = stack.peek();
  28.             MenuComponent component = (MenuComponent) iterator.next();
  29.             if (component instanceof Menu) {
  30.                 Iterator menuIterator = component.createIterator();
  31.                 if (!stack.contains(menuIterator)) {
  32.                     stack.push(menuIterator);
  33.                 }
  34.             }
  35.             return component;
  36.         }
  37.  
  38.         return null;
  39.     }
  40.  
  41.     @Override
  42.     public void remove() {
  43.         throw new UnsupportedOperationException();
  44.     }
  45. }

这里的栈结构使用得很巧妙，因为这个栈的使用让我想到在 LeetCode 上的一道算法题，也是使用栈来实现，而且比一般的算法复杂度低很多，如果我不犯懒的话，应该会写那一篇博客的。咳咳，扯远了，回到正题。有关于栈的使用是一些数据结构和 Java api 的基础，这里不多说什么了。还有这里的 hasNext() 和 next() 方法，这里要求你对数据结构和 Java api（主要是 Stack 这一块）比较熟悉。所以，如果你看到这个地方有什么不太理解的，可以留言，也可以自行复习一下这两块内容。

NullIterator.java

  1. public class NullIterator implements Iterator<MenuComponent> {
  2.  
  3.     @Override
  4.     public boolean hasNext() {
  5.         return false;
  6.     }
  7.  
  8.     @Override
  9.     public MenuComponent next() {
  10.         return null;
  11.     }
  12.  
  13.     @Override
  14.     public void remove() {
  15.         throw new UnsupportedOperationException();
  16.     }
  17. }

因为每个菜单项都不可能什么子菜单项，也就不存在什么迭代器了，所以在 MenuItem 中就可以返回一个 Null 的迭代器。当然，这是理想的做法。你也可以直接返回 null，只是这样一来，在上层就要多一次判空处理，相比较而言，这样的实现更优雅。
程序的结果自然不出所料：

  1. 素食菜单（迭代）
  2. MenuItem: { 包子, bun, true, 1.5 }
  3. MenuItem: { 油条, fritters, true, 1.2 }
  4. MenuItem: { 豆浆, milk, true, 2.0 }
  5. MenuItem: { 炒米粉, Fried noodles, true, 8.0 }
  6. MenuItem: { 冰淇淋, ice cream, true, 5.0 }

只是，如果你只采用书本上的迭代器来实现，就会出现多级菜单下的菜单项被 show 了 N 遍。而你只能一脸懵逼。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_43842093/article/details/122890571

内容来源于网络，如有侵权，请联系作者删除！

Java设计模式java设计模式

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com