zoukankan      html  css  js  c++  java

  • 组合模式与迭代器模式

    转载:http://blog.csdn.net/cai1213/article/details/7991482

      组合模式

    允许你将对象组合成树形结构来表现“整体/部分”层析结构。组合能让客户以一致的方式处理个别对象以及对象组合。

    我们以菜单为例思考这一切：这个模式能够创建一个树形结构，在同一个结构中处理嵌套菜单和菜单项组。通过将菜单和项放在相同的结构中，我们创建了一个“整体/部分”层次结构，即由菜单和菜单项组成的对象树。但是可以将它视为一个整体，像是一个丰富的大菜单。一旦有了丰富的大菜单，我们就可以使用这个模式来“统一处理个别对象和组合对象”。这意味着，如果我们有了一个树形结构的菜单、子菜单和可能还带有菜单项的子菜单，那么任何一个菜单都是一种“组合”。因为它既可以包含其他菜单，也可以包含菜单项。个别对象只是菜单项——并未持有其他对象。

            具体例子

    组件类：MenuComponent.java

    <head first 设计模式>

    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.Iterator;  
    4.   
    5. public abstract class MenuComponent {  
    6.       
    7.     public void add(MenuComponent menuComponent){  
    8.         throw new UnsupportedOperationException();  
    9.     }  
    10.       
    11.     public void remove(MenuComponent menuComponent){  
    12.         throw new UnsupportedOperationException();  
    13.     }  
    14.       
    15.     public MenuComponent getChild(int i){  
    16.         throw new UnsupportedOperationException();  
    17.     }  
    18.       
    19.     public String getName(){  
    20.         throw new UnsupportedOperationException();  
    21.     }  
    22.       
    23.     public String getDescription(){  
    24.         throw new UnsupportedOperationException();  
    25.     }  
    26.       
    27.     public double getPrice(){  
    28.         throw new UnsupportedOperationException();  
    29.     }  
    30.       
    31.     public boolean isVegetarian(){  
    32.         throw new UnsupportedOperationException();  
    33.     }  
    34.       
    35.     public void print(){  
    36.         throw new UnsupportedOperationException();  
    37.     }  
    38.       
    39.     public Iterator<?> createIterator(){  
    40.         throw new UnsupportedOperationException();  
    41.     }  
    42. }  

    菜单项：MenuItem.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.Iterator;  
    4.   
    5. public class MenuItem extends MenuComponent{  
    6.     String name;  
    7.     String description;  
    8.     boolean vegetarian;  
    9.     double price;  
    10.       
    11.     public MenuItem(String name, String description,   
    12.                     boolean vegetarian, double price){  
    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.     }  
    34.   
    35.     //菜单项无需迭代，直接打印即可；  
    36.     public void print() {  
    37.         System.out.print("2 " + getName());  
    38.         if(isVegetarian()){  
    39.             System.out.print("(v)");  
    40.         }  
    41.         System.out.println(", " + getPrice());  
    42.         System.out.println("  -- " + getDescription());  
    43.     }  
    44.   
    45.     //外部迭代器；  
    46.     public Iterator<?> createIterator() {  
    47.         return new NullIterator();  
    48.     }  
    49.       
    50.       
    51. }  

    菜单：Menu.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.Iterator;  
    5.   
    6. public class Menu extends MenuComponent{  
    7.     ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();  
    8.     String name;  
    9.     String description;  
    10.   
    11.     public Menu(String name, String description){  
    12.         this.name = name;  
    13.         this.description = description;  
    14.     }  
    15.       
    16.     public void add(MenuComponent menuComponent) {  
    17.         menuComponents.add(menuComponent);  
    18.     }  
    19.       
    20.     public void remove(MenuComponent menuComponent) {  
    21.         menuComponents.remove(menuComponent);  
    22.     }  
    23.   
    24.     public MenuComponent getChild(int i) {  
    25.         return (MenuComponent)menuComponents.get(i);  
    26.     }  
    27.   
    28.     public String getName() {  
    29.         return name;  
    30.     }  
    31.       
    32.     public String getDescription() {  
    33.         return description;  
    34.     }  
    35.   
    36.     public void print() {  
    37.         System.out.print("1 " + getName());  
    38.         System.out.println(", " + getDescription());  
    39.         System.out.println("-------------------");  
    40.           
    41.         /** 
    42.          * 内部迭代器 
    43.          *  
    44.          * 用它遍历所有菜单组件，可能是菜单项，也有可能是菜单； 
    45.          * 注意：如果遇到另一个菜单对象，它的print（）方法会开始另一个遍历，以此类推； 
    46.          *  
    47.          * */  
    48.         Iterator<?> iterator = menuComponents.iterator();  
    49.         while (iterator.hasNext()) {  
    50.             MenuComponent menuComponent = (MenuComponent)iterator.next();  
    51.             menuComponent.print();  
    52.         }  
    53.     }  
    54.       
    55.     //外部迭代器  
    56.     public Iterator<?> createIterator() {  
    57.         return new CompositeIterator(menuComponents.iterator());  
    58.     }  
    59.       
    60.       
    61. }  

    菜单项迭代器：NullIterator.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.Iterator;  
    4.   
    5. public class NullIterator implements Iterator<Object>{  
    6.   
    7.     @Override  
    8.     public boolean hasNext() {  
    9.         // TODO Auto-generated method stub  
    10.         return false;  
    11.     }  
    12.   
    13.     @Override  
    14.     public Object next() {  
    15.         // TODO Auto-generated method stub  
    16.         return null;  
    17.     }  
    18.   
    19.     @Override  
    20.     public void remove() {  
    21.         // TODO Auto-generated method stub  
    22.         throw new UnsupportedOperationException();  
    23.     }  
    24.   
    25. }  

    菜单迭代器：CompositeIterator.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.Iterator;  
    4. import java.util.Stack;  
    5.   
    6. public class CompositeIterator implements Iterator<Object>{  
    7.     Stack<Object> stack = new Stack<Object>();  
    8.       
    9.     public CompositeIterator(Iterator<?> iterator){  
    10.         stack.push(iterator);  
    11.     }  
    12.       
    13.     public boolean hasNext() {  
    14.         if(stack.empty()){  
    15.             return false;  
    16.         }else{  
    17.             Iterator<?> iterator = (Iterator<?>) stack.peek();  
    18.             if(!iterator.hasNext()){  
    19.                 stack.pop();  
    20.                 return hasNext();  
    21.             } else{  
    22.                 return true;  
    23.             }  
    24.         }  
    25.     }  
    26.   
    27.     public Object next() {  
    28.         if(hasNext()){  
    29.             Iterator<?> iterator = (Iterator<?>) stack.peek();  
    30.             MenuComponent component = (MenuComponent) iterator.next();  
    31.             if(component instanceof Menu){  
    32.                 //如果元素是一个菜单，我们有了另一个需要被包含进遍历的组合，所以我们将它丢入到堆栈中。
    33.                 stack.push(component.createIterator());  
    34.             }  
    35.             return component;  
    36.         }else{  
    37.             return null;  
    38.         }  
    39.     }  
    40.   
    41.     public void remove() {  
    42.         throw new UnsupportedOperationException();  
    43.     }  
    44.   
    45. }  

    操作者：Waitress.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. import java.util.Iterator;  
    4.   
    5. /** 
    6.  * 操作菜单的类  
    7.  * */  
    8. public class Waitress {  
    9.     MenuComponent allMenus;  
    10.       
    11.     public Waitress(MenuComponent allMenus){  
    12.         this.allMenus = allMenus;  
    13.     }  
    14.       
    15.     public void printMenu(){  
    16.         allMenus.print();  
    17.     }  
    18.       
    19.     //使用外部迭代器  
    20.     public void printVegetarianMenu(){  
    21.         Iterator<?> iterator = allMenus.createIterator();  
    22.         System.out.println(" VEGETARIAN MENU ----");  
    23.           
    24.         while(iterator.hasNext()){  
    25.             MenuComponent menuComponent = (MenuComponent)iterator.next();  
    26.             try {  
    27.                 if(menuComponent.isVegetarian()){  
    28.                     menuComponent.print();  
    29.                 }  
    30.             } catch (UnsupportedOperationException e) {  
    31.             }  
    32.         }  
    33.     }  
    34. }  

    测试类：Test.java
    [java] view plain copy
     
    1. package com.designpattern.composite_iterator;  
    2.   
    3. public class Test {  
    4.     public static void main(String[] args) {  
    5.         MenuComponent pancakeHouseMenu = new Menu("PANCAKE HOUSE MENU", "Breakfast");     
    6.           
    7.         MenuComponent dinerMenu = new Menu("DINER MENU", "Lunch");  
    8.         dinerMenu.add(new MenuItem("Pasta", "Spaghetti with Marinara Sauce, and a slice of sourdough bread", true, 3.89));  
    9.         MenuComponent dessertMenu = new Menu("DESSERT MENU", "Dessert of course!");  
    10.         dessertMenu.add(new MenuItem("Apple Pie", "Apple pie with a flakey crust, topped with vanilla ice cream", true, 1.59));  
    11.         dinerMenu.add(dessertMenu);  
    12.           
    13.         MenuComponent cafeMenu = new Menu("CAFE MENU", "Dinner");  
    14.           
    15.         MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");  
    16.           
    17.         allMenus.add(pancakeHouseMenu);  
    18.         allMenus.add(dinerMenu);  
    19.         allMenus.add(cafeMenu);  
    20.           
    21.         Waitress waitress = new Waitress(allMenus);  
    22.         waitress.printMenu();  
    23.         waitress.printVegetarianMenu();  
    24.     }  
    25. }  

             总结

    在写MenuComponent类的print()方法时，我们利用了一个迭代器来遍历组件内的每个项。如果遇到的是菜单（而不是菜单项），我们就会递归地调用print()方法处理它。换句话说，MenuComponent是在“内部”自行处理遍历。

    但在Waitress类中，我们实现的是一个“外部”迭代器，所以有许多需要追踪的事情。外部迭代器必须维护它在遍历中的位置，以便外部客户可以通过调用hasNext()和next()来驱动遍历。在这个例子中，我们的代码也必须维护组合递归结构的位置。这也就是为什么当我们在组合层次结构中上上下下时，使用堆栈来维护我们的位置。

    但是存在一个问题：外部迭代器时有的数据会打印多遍，取决于层级结构，这个貌似是迭代器本身的问题，想只打印一遍数据，需另作处理，或者直接用“内部”迭代器的方式。
  • 相关阅读:
    Linq 入门 顺带 Func与Action
    关于asp.net 的一些好资料地址 , 防止丢失!
    Sql日期时间格式转换 备用
    自己动手写 ASP.NET MVC 分页 part1
    怎么做好一个美食排行榜的用户投票功能？
    「要买车网」免费获取汽车电商要买车网购车优惠券
    MVC Ajax Form & Ajax Valida(笔记)
    C# 序列化高级用法
    我与葡萄城的故事
    生成分布式随机ID
  • 原文地址：https://www.cnblogs.com/fanguangdexiaoyuer/p/5865138.html
Copyright © 2011-2022 走看看