devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计模式-组合模式_组合设计模式菜鸟

作者：不正经 | 2024-05-22 06:02:26

赞

踩

组合设计模式菜鸟

组合模式定义

组合模式允许你将对象组合成树形结构来表现部分-整体层次结构。组合让客户可以统一处理个别对象和对象的组合。

分析：这个模式感觉接触的很少，不过感觉也是挺有用的，从上一篇博客中学习了有关迭代器模式的东西，总结就是在看不到内部结构的基础上对其进行遍历。

如果从遍历的角度看，假设我们有两份菜单，要对菜单中的数据进行遍历，这个时候我就可以使用迭代器模式进行考虑遍历，两份菜单对应两个迭代器，同样也有两份菜单类，由于我用了java列表的迭代器，就不用自己再次封装迭代器了，如我给出以下示例：

Menu接口，就是定义了菜单有哪些方法：

  1. public interface Menu {
  2.  
  3.     Iterator<MenuItem> createIterator();
  4.  
  5. }

两个具体的菜单如下：

  1. public class TeaMenu implements Menu {
  2.  
  3.     private List<MenuItem> teaList;
  4.  
  5.     public TeaMenu(List<MenuItem> teaList) {
  6.         this.teaList = teaList;
  7.     }
  8.  
  9.     @Override
  10.     public Iterator<MenuItem> createIterator() {
  11.         return teaList.iterator();
  12.     }
  13. }
  14.  
  15. public class MeatMeun implements Menu {
  16.  
  17.     private List<MenuItem> meatList;
  18.  
  19.     public MeatMeun(List<MenuItem> meatList) {
  20.         this.meatList = meatList;
  21.     }
  22.  
  23.     @Override
  24.     public Iterator<MenuItem> createIterator() {
  25.         return meatList.iterator();
  26.     }
  27. }

菜单项类如下：

  1. public class MenuItem {
  2.  
  3.     private String name;
  4.     private double price;
  5.     private String description;
  6.  
  7.     public MenuItem(String name, double price, String description) {
  8.         this.name = name;
  9.         this.price = price;
  10.         this.description = description;
  11.     }
  12.  
  13.     public String getName() {
  14.         return name;
  15.     }
  16.  
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.  
  21.     public double getPrice() {
  22.         return price;
  23.     }
  24.  
  25.     public void setPrice(double price) {
  26.         this.price = price;
  27.     }
  28.  
  29.     public String getDescription() {
  30.         return description;
  31.     }
  32.  
  33.     public void setDescription(String description) {
  34.         this.description = description;
  35.     }
  36.  
  37.     @Override
  38.     public String toString() {
  39.         return "MenuItem{" +
  40.                 "name='" + name + '\'' +
  41.                 ", price=" + price +
  42.                 ", description='" + description + '\'' +
  43.                 '}';
  44.     }
  45. }

商店类，就是为了展示菜单：

  1. public class Shop {
  2.  
  3.     private Menu teaMenu;
  4.     private Menu meatMeun;
  5.  
  6.     public Shop(Menu teaMenu, Menu meatMeun) {
  7.         this.teaMenu = teaMenu;
  8.         this.meatMeun = meatMeun;
  9.     }
  10.  
  11.     public void printMenu(){
  12.         Iterator<MenuItem> mIterator = this.meatMeun.createIterator();
  13.         Iterator<MenuItem> tIterator = this.teaMenu.createIterator();
  14.         while(mIterator.hasNext()){
  15.             MenuItem next = mIterator.next();
  16.             System.out.println(next);
  17.         }
  18.         while(tIterator.hasNext()){
  19.             MenuItem next = tIterator.next();
  20.             System.out.println(next);
  21.         }
  22.     }
  23.  
  24.     public static void main(String[] args) {
  25.         List<MenuItem> meatList = new ArrayList<>();
  26.         meatList.add(new MenuItem("猪肉",10,"10块一斤"));
  27.         meatList.add(new MenuItem("牛肉",50,"50块一斤"));
  28.         meatList.add(new MenuItem("羊肉",60,"60块一斤"));
  29.         Menu meatMenu = new MeatMeun(meatList);
  30.         List<MenuItem> teaList = new ArrayList<>();
  31.         teaList.add(new MenuItem("红豆奶茶",10,"10块一杯"));
  32.         teaList.add(new MenuItem("珍珠奶茶",11,"11块一杯"));
  33.         teaList.add(new MenuItem("椰果奶茶",12,"12块一杯"));
  34.         Menu teaMenu = new MeatMeun(teaList);
  35.         Shop shop = new Shop(teaMenu, meatMenu);
  36.         shop.printMenu();
  37.     }
  38.  
  39. }

上述使用迭代器模式对商店里的菜单内容进行了遍历，但是会发现一个问题，就是如果商店里的肉类菜单下有子类呢，比如分为生肉和熟肉，生肉下分别是生猪肉，生牛肉，生羊肉，而茶菜单又分为奶茶和果茶，奶茶分别为红豆奶茶，珍珠奶茶，椰果奶茶，果茶分为，草莓果茶，百香果果茶，芒果果茶。

如果按照上述情况，就会出现问题，本来的，茶菜单和肉菜单无法表示这种分类关系，而且上述出现了二级菜单，对于原来的菜单也无法表示这种层级关系，所以这种菜单的设计结构将无法进行扩展，对于商店去处理的时候，代码也无法重构，而且也不应该让代码进行经常性的重构，所以这个时候我们就要考虑组合模式了。那么接下来我们看一看组合模式的类图。

组合模式类图

从上面的类图我们要进行提炼几点内容： 

在这里，我们让所有的类都继承自Component类，然后叶子节点将不包含任何内容，而Composite作为一种分支节点类。所以如果动用组合模式，我们就可以将上述内容衍化成下面这种模式。

所以包含肉菜单和茶菜单的类就是根节点，包含生肉和熟肉的肉菜单就是二级节点，其余都是叶子节点。那么这个改造就很清晰了。 我们用代码给出。

组合模式示例代码

  1. //叶子节点
  2. public class MenuItem extends MenuComponent{
  3.  
  4.     private String name;
  5.     private double price;
  6.     private String description;
  7.  
  8.     public MenuItem(String name, double price, String description) {
  9.         this.name = name;
  10.         this.price = price;
  11.         this.description = description;
  12.     }
  13.  
  14.     public String getName() {
  15.         return name;
  16.     }
  17.  
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  21.  
  22.     public double getPrice() {
  23.         return price;
  24.     }
  25.  
  26.     public void setPrice(double price) {
  27.         this.price = price;
  28.     }
  29.  
  30.     public String getDescription() {
  31.         return description;
  32.     }
  33.  
  34.     @Override
  35.     public void print() {
  36.         System.out.println(toString());
  37.     }
  38.  
  39.     public void setDescription(String description) {
  40.         this.description = description;
  41.     }
  42.  
  43.     @Override
  44.     public String toString() {
  45.         return "MenuItem{" +
  46.                 "name='" + name + '\'' +
  47.                 ", price=" + price +
  48.                 ", description='" + description + '\'' +
  49.                 '}';
  50.     }
  51. }
  52.  
  53. public abstract class MenuComponent {
  54.  
  55.     public void add(MenuComponent menuComponent){
  56.  
  57.     }
  58.  
  59.     public void remove(MenuComponent menuComponent){
  60.  
  61.     }
  62.  
  63.     public MenuComponent getChild(int i){
  64.         return null;
  65.     }
  66.  
  67.     abstract String getName();
  68.  
  69.     abstract String getDescription();
  70.  
  71.     abstract void print();
  72.  
  73.  
  74. }
  75.  
  76.  
  77. //分支节点
  78. public class Menu extends MenuComponent {
  79.  
  80.     private List<MenuComponent> list = new ArrayList<>();
  81.     String name;
  82.     String description;
  83.  
  84.     public Menu(String name, String description) {
  85.         this.name = name;
  86.         this.description = description;
  87.     }
  88.  
  89.     @Override
  90.     public void add(MenuComponent menuComponent) {
  91.         list.add(menuComponent);
  92.     }
  93.  
  94.     @Override
  95.     public void remove(MenuComponent menuComponent) {
  96.         list.remove(menuComponent);
  97.     }
  98.  
  99.     @Override
  100.     public MenuComponent getChild(int i) {
  101.         return list.get(i);
  102.     }
  103.  
  104.     @Override
  105.     String getName() {
  106.         return name;
  107.     }
  108.  
  109.     @Override
  110.     String getDescription() {
  111.         return description;
  112.     }
  113.  
  114.     @Override
  115.     void print() {
  116.         System.out.println("\n" + getName());
  117.         System.out.println("," + getDescription());
  118.         System.out.println("-------------------");
  119.         for (MenuComponent m: list) {
  120.             m.print();
  121.         }
  122.     }
  123.  
  124. }
  125.  
  126.  
  127. public class Client {
  128.  
  129.     public static void main(String[] args) {
  130.         MenuComponent root = new Menu("菜单","我是菜单");
  131.         MenuComponent meat = new Menu("肉类菜单","我是肉类菜单");
  132.         MenuComponent ripeMeat = new Menu("熟肉类菜单","我是熟肉类菜单");
  133.         ripeMeat.add(new MenuItem("熟羊肉",100,"熟羊肉100元一斤"));
  134.         ripeMeat.add(new MenuItem("熟猪肉",30,"熟猪肉30元一斤"));
  135.         ripeMeat.add(new MenuItem("熟牛肉",90,"熟牛肉90元一斤"));
  136.         MenuComponent rawMeat = new Menu("生肉类菜单","我是生肉类菜单");
  137.         rawMeat.add(new MenuItem("生羊肉",50,"生羊肉50元一斤"));
  138.         rawMeat.add(new MenuItem("生猪肉",15,"生猪肉15元一斤"));
  139.         rawMeat.add(new MenuItem("生牛肉",45,"生牛肉45元一斤"));
  140.         meat.add(rawMeat);
  141.         meat.add(ripeMeat);
  142.         MenuComponent tea = new Menu("茶菜单","我是茶菜单");
  143.         MenuComponent milkTea = new Menu("奶茶菜单","我是奶茶菜单");
  144.         milkTea.add(new MenuItem("珍珠奶茶",10,"珍珠奶茶10一杯"));
  145.         milkTea.add(new MenuItem("红豆奶茶",11,"红豆奶茶11一杯"));
  146.         milkTea.add(new MenuItem("椰果奶茶",12,"椰果奶茶12一杯"));
  147.         MenuComponent fruitTea = new Menu("果茶菜单","我是果茶菜单");
  148.         fruitTea.add(new MenuItem("草莓果茶",15,"草莓果茶15一杯"));
  149.         fruitTea.add(new MenuItem("百香果果茶",15,"百香果茶15一杯"));
  150.         fruitTea.add(new MenuItem("芒果果茶",15,"芒果果茶15一杯"));
  151.         tea.add(milkTea);
  152.         tea.add(fruitTea);
  153.         root.add(meat);
  154.         root.add(tea);
  155.         root.print();
  156.     }
  157.  
  158. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/606750
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号