经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
设计模式之迭代器与组合模式（四）
来源：cnblogs　　作者：小酒窝　　时间：2019/6/27 9:30:49　　对本文有异议

因为这系列篇幅较长，所以在这里也不进行任何铺垫，直奔主题去啦。

利用组合设计菜单

我们要如何在菜单上应用组合模式呢？一开始，我们需要创建一个组件接口来作为菜单和菜单项的共同接口，让我们能够用统一的做法来处理菜单和菜单项。换句话说，我们可以针对菜单或菜单项调用相同的方法。

让我们从头来看看如何让菜单能够符合组合模式的结构：

实现菜单组件

好了，我们开始编写菜单组件的抽象类；请记住，菜单组件的角色是为叶节点和组合节点提供一个共同的接口。

  1. public abstract class MenuComponent {
  2.    
  3.     public void add(MenuComponent menuComponent) {
  4.         throw new UnsupportedOperationException();
  5.     }
  6.     public void remove(MenuComponent menuComponent) {
  7.         throw new UnsupportedOperationException();
  8.     }
  9.     public MenuComponent getChild(int i) {
  10.         throw new UnsupportedOperationException();
  11.     }
  12.   
  13.     public String getName() {
  14.         throw new UnsupportedOperationException();
  15.     }
  16.     public String getDescription() {
  17.         throw new UnsupportedOperationException();
  18.     }
  19.     public double getPrice() {
  20.         throw new UnsupportedOperationException();
  21.     }
  22.     public boolean isVegetarian() {
  23.         throw new UnsupportedOperationException();
  24.     }
  26.     public abstract Iterator<MenuComponent> createIterator();
  27.  
  28.     public void print() {
  29.         throw new UnsupportedOperationException();
  30.     }
  31. }

让我们来看菜单类。别忘了，这是组合类图里的叶类，它实现组合内元素的行为。

  1. public class MenuItem extends MenuComponent {
  2.  
  3.     String name;
  4.     String description;
  5.     boolean vegetarian;
  6.     double price;
  7.     
  8.     public MenuItem(String name, 
  9.                     String description, 
  10.                     boolean vegetarian, 
  11.                     double price) 
  12.     { 
  13.         this.name = name;
  14.         this.description = description;
  15.         this.vegetarian = vegetarian;
  16.         this.price = price;
  17.     }
  18.   
  19.     public String getName() {
  20.         return name;
  21.     }
  22.   
  23.     public String getDescription() {
  24.         return description;
  25.     }
  26.   
  27.     public double getPrice() {
  28.         return price;
  29.     }
  30.   
  31.     public boolean isVegetarian() {
  32.         return vegetarian;
  33.     }
  35.     public Iterator<MenuComponent> createIterator() {
  36.         return new NullIterator();
  37.     }
  38.  
  39.     public void print() {
  40.         System.out.print("  " + getName());
  41.         if (isVegetarian()) {
  42.             System.out.print("(v)");
  43.         }
  44.         System.out.println(", " + getPrice());
  45.         System.out.println("     -- " + getDescription());
  46.     }
  48. }

我们已经有了菜单项，还需要组合类，这就是我们叫做菜单的。别忘了，此组合类可以持有菜单项或其他菜单。

  1. public class Menu extends MenuComponent {
  2.     Iterator<MenuComponent> iterator = null;
  3.     ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
  4.     String name;
  5.     String description;
  6.   
  7.     public Menu(String name, String description) {
  8.         this.name = name;
  9.         this.description = description;
  10.     }
  11.  
  12.     public void add(MenuComponent menuComponent) {
  13.         menuComponents.add(menuComponent);
  14.     }
  15.  
  16.     public void remove(MenuComponent menuComponent) {
  17.         menuComponents.remove(menuComponent);
  18.     }
  19.  
  20.     public MenuComponent getChild(int i) {
  21.         return menuComponents.get(i);
  22.     }
  23.  
  24.     public String getName() {
  25.         return name;
  26.     }
  27.  
  28.     public String getDescription() {
  29.         return description;
  30.     }
  32.   
  33.     public Iterator<MenuComponent> createIterator() {
  34.         if (iterator == null) {
  35.             iterator = new CompositeIterator(menuComponents.iterator());
  36.         }
  37.         return iterator;
  38.     }
  39.  
  40.  
  41.     public void print() {
  42.         System.out.print("\n" + getName());
  43.         System.out.println(", " + getDescription());
  44.         System.out.println("---------------------");
  45.     }
  46. }

因为菜单是一个组合，包含了菜单项和其他的菜单，所以它的print()应该打印出它所包含的一切。如果它不这么做，我们就必须遍历整个组合的每个节点，然后将每一项打印出来。这么一来，也就失去了使用组合结构的意义。

所以，print还得进行优化，如下:

  1. public void print() {
  2.     System.out.print("\n" + getName());
  3.     System.out.println(", " + getDescription());
  4.     System.out.println("---------------------");
  5.  
  6.     Iterator<MenuComponent> iterator = menuComponents.iterator();
  7.     while (iterator.hasNext()) {
  8.         MenuComponent menuComponent = iterator.next();
  9.         menuComponent.print();
  10.     }
  11. }

看到上面了没，我们用了迭代器。用它遍历所有菜单组件，遍历过程中，可能遇到其他菜单，或者是遇到菜单项。由于菜单和菜单项都实现了print，那我们只要调用print即可。

开始测试数据之前，我们了解一下，在运行时菜单组合是什么样的：

开始运行我们的测试程序啦:

  1. public class MenuTestDrive {
  2.     public static void main(String args[]) {
  4.         MenuComponent pancakeHouseMenu = 
  5.             new Menu("PANCAKE HOUSE MENU", "Breakfast");
  6.         MenuComponent dinerMenu = 
  7.             new Menu("DINER MENU", "Lunch");
  8.         MenuComponent cafeMenu = 
  9.             new Menu("CAFE MENU", "Dinner");
  10.         MenuComponent dessertMenu = 
  11.             new Menu("DESSERT MENU", "Dessert of course!");
  12.   
  13.         MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");
  14.   
  15.         allMenus.add(pancakeHouseMenu);
  16.         allMenus.add(dinerMenu);
  17.         allMenus.add(cafeMenu);
  18.   
  19.         pancakeHouseMenu.add(new MenuItem(
  20.             "K&B's Pancake Breakfast", 
  21.             "Pancakes with scrambled eggs, and toast", 
  22.             true,
  23.             2.99));
  24.         pancakeHouseMenu.add(new MenuItem(
  25.             "Regular Pancake Breakfast", 
  26.             "Pancakes with fried eggs, sausage", 
  27.             false,
  28.             2.99));
  29.         pancakeHouseMenu.add(new MenuItem(
  30.             "Blueberry Pancakes",
  31.             "Pancakes made with fresh blueberries, and blueberry syrup",
  32.             true,
  33.             3.49));
  34.         pancakeHouseMenu.add(new MenuItem(
  35.             "Waffles",
  36.             "Waffles, with your choice of blueberries or strawberries",
  37.             true,
  38.             3.59));
  40.         dinerMenu.add(new MenuItem(
  41.             "Vegetarian BLT",
  42.             "(Fakin') Bacon with lettuce & tomato on whole wheat", 
  43.             true, 
  44.             2.99));
  45.         dinerMenu.add(new MenuItem(
  46.             "BLT",
  47.             "Bacon with lettuce & tomato on whole wheat", 
  48.             false, 
  49.             2.99));
  50.         dinerMenu.add(new MenuItem(
  51.             "Soup of the day",
  52.             "A bowl of the soup of the day, with a side of potato salad", 
  53.             false, 
  54.             3.29));
  55.         dinerMenu.add(new MenuItem(
  56.             "Hotdog",
  57.             "A hot dog, with saurkraut, relish, onions, topped with cheese",
  58.             false, 
  59.             3.05));
  60.         dinerMenu.add(new MenuItem(
  61.             "Steamed Veggies and Brown Rice",
  62.             "A medly of steamed vegetables over brown rice", 
  63.             true, 
  64.             3.99));
  65.  
  66.         dinerMenu.add(new MenuItem(
  67.             "Pasta",
  68.             "Spaghetti with Marinara Sauce, and a slice of sourdough bread",
  69.             true, 
  70.             3.89));
  71.    
  72.         dinerMenu.add(dessertMenu);
  73.   
  74.         dessertMenu.add(new MenuItem(
  75.             "Apple Pie",
  76.             "Apple pie with a flakey crust, topped with vanilla icecream",
  77.             true,
  78.             1.59));
  79.         dessertMenu.add(new MenuItem(
  80.             "Cheesecake",
  81.             "Creamy New York cheesecake, with a chocolate graham crust",
  82.             true,
  83.             1.99));
  84.         dessertMenu.add(new MenuItem(
  85.             "Sorbet",
  86.             "A scoop of raspberry and a scoop of lime",
  87.             true,
  88.             1.89));
  90.         cafeMenu.add(new MenuItem(
  91.             "Veggie Burger and Air Fries",
  92.             "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
  93.             true, 
  94.             3.99));
  95.         cafeMenu.add(new MenuItem(
  96.             "Soup of the day",
  97.             "A cup of the soup of the day, with a side salad",
  98.             false, 
  99.             3.69));
  100.         cafeMenu.add(new MenuItem(
  101.             "Burrito",
  102.             "A large burrito, with whole pinto beans, salsa, guacamole",
  103.             true, 
  104.             4.29));
  105.  
  106.         Waitress waitress = new Waitress(allMenus);
  107.    
  108.         waitress.printVegetarianMenu();
  109.  
  110.     }
  111. }

结果这里就不附上了，请大家自行去跑代码实现吧。相信你们又对组合模式也已经有了一个大概了吧。下一篇，还有更犀利的，组合迭代器等着我们。小编马上回去搞起来，安排上。

爱生活，爱学习，爱感悟，爱挨踢

原文链接：http://www.cnblogs.com/dimple91/p/11089204.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号