组合模式与迭代器模式

转载: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\n" + 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("\nVEGETARIAN MENU\n----");  
  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()来驱动遍历。在这个例子中，我们的代码也必须维护组合递归结构的位置。这也就是为什么当我们在组合层次结构中上上下下时，使用堆栈来维护我们的位置。

但是存在一个问题：外部迭代器时有的数据会打印多遍，取决于层级结构，这个貌似是迭代器本身的问题，想只打印一遍数据，需另作处理，或者直接用“内部”迭代器的方式。

posted on 2016-09-12 16:03  反光的小鱼儿  阅读(255)  评论(0)  编辑  收藏  举报