迭代器模式笔记

迭代器模式：

定义

    提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

例子

Iterator 接口：

public interface Iterator {
	boolean hasNext();
	Object next();
}

Menu接口：

public interface Menu {
	public Iterator createIterator();
}

菜单类：

public class MenuItem {
	String name;
	String description;
	boolean vegetarian;
	double price;
	
	public MenuItem(String name,String description,boolean vegetarian,double price){
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}
	
	public String getName(){
		return name;
	}
	
	public String getDescription(){
		return description;
	}
	
	public double getPrice(){
		return price;
	}
	
	public boolean isVegetarian(){
		return vegetarian;
	}
}

DinnerMenu类与它的迭代器

public class DinnerMenu implements Menu {
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;
	
	public DinnerMenu(){
		menuItems = new MenuItem[MAX_ITEMS];
		
		addItem("Vegetarian BLT", "F B with lettuce & tomato on whole wheat", true, 2.99);
		addItem("BLT", "Bacon with lettuce & tomato on whole wheat", false, 2.99);
		addItem("Soup of the day", "Soup of the day,with a side of potato salad", false, 3.29);
		addItem("Hotdog", "A hot dog, with saurkraut, relish, onions, topped with cheese ", false, 3.05);
	}
	
	public void addItem(String name,String description,boolean vegetarian,double price){
		MenuItem menuItem = new MenuItem(name,description,vegetarian,price);
		if(numberOfItems >= MAX_ITEMS){
			System.err.print("Error,menu is full!");
		} else{
			menuItems[numberOfItems] = menuItem;
			numberOfItems = numberOfItems + 1;
		}
	}
	
	public MenuItem[] getMenuItems(){
		return menuItems;
	}
	
	public Iterator createIterator(){
		return new DinerMenuIterator(menuItems);
	}
}

public class DinerMenuIterator implements Iterator {

	MenuItem[] items;
	int position = 0;

	public DinerMenuIterator(MenuItem[] items) {
		this.items = items;
	}

	@Override
	public boolean hasNext() {
		if (position >= items.length || items[position] == null) {
			return false;
		} else {
			return true;
		}
	}

	@Override
	public Object next() {
		MenuItem menuItem = items[position];
		position = position + 1;
		return menuItem;
	}
}

PancakeHouseMenu类与它的迭代器

public class PancakeHouseMenu implements Menu {

	ArrayList menuItems;
	
	public PancakeHouseMenu(){
		menuItems = new ArrayList();
		
		addItem("KB Pancake Breakfast", "Pancakes with scrambled eggs and toast",true , 2.99);
		addItem("Regular Pancake Breakfast", "Pancakes with fried eggs and sausage",false , 2.99);
		addItem("Blueberry Pancake", "Pancakes made with fresh blueberries",true , 3.49);
		addItem("Waffles", "Wafles,with your choice of blueberries or strawberries",true , 3.59);
	}
	
	public void addItem(String name,String description,boolean vegetarian,double price){
		MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
		menuItems.add(menuItem);
	}
	
	public ArrayList getMenuItems(){
		return menuItems;
	}
	
	public Iterator createIterator(){
		return new PancakeHouseMenuIterator(menuItems);
	}
}

public class PancakeHouseMenuIterator implements Iterator {

	ArrayList items;
	int position = 0;

	public PancakeHouseMenuIterator(ArrayList items) {
		this.items = items;
	}

	@Override
	public boolean hasNext() {
		if (position >= items.size()) {
			return false;
		} else {
			return true;
		}
	}

	@Override
	public Object next() {
		MenuItem menuItem = (MenuItem) items.get(position);
		position = position + 1;
		return menuItem;
	}
}

服务员与测试类

优化前：

public class Waitress {
	
	Menu pancakeHouseMenu;
	Menu dinnerMenu;
	
	public Waitress(Menu pancakeHouseMenu,Menu dinnerMenu){
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinnerMenu = dinnerMenu;
	}
	
	public void printMenu(){
		Iterator pancakeIterator = pancakeHouseMenu.createIterator();
		System.out.println("pancake");
		printMenu(pancakeIterator);
		Iterator dinerIterator = dinnerMenu.createIterator();
		System.out.println("\n Lunch");
		printMenu(dinerIterator);
		
	}
	
	public void printMenu(Iterator iterator){
		while(iterator.hasNext()){
			MenuItem menuItem = (MenuItem)iterator.next();
			System.out.println(menuItem.getName() + ", ");
			System.out.println(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}
}

public class MenuTestDrive {

	public static void main(String[] args) {
		PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
		DinnerMenu dinerMenu = new DinnerMenu();
		Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
		waitress.printMenu();
	}

}

当需要扩展时需要修改服务员类内部结构，违反了设计原则，故优化后:

public class Waitress {
	
	ArrayList menus;
	
	public Waitress(ArrayList menus){
		this.menus = menus;
	}
	
	public void printMenu(){
		java.util.Iterator menuIterator = menus.iterator();
		while(menuIterator.hasNext()){
			Menu menu = (Menu) menuIterator.next();
			printMenu(menu.createIterator());
		}
	}
	
	public void printMenu(Iterator iterator){
		while(iterator.hasNext()){
			MenuItem menuItem = (MenuItem)iterator.next();
			System.out.println(menuItem.getName() + ", ");
			System.out.println(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}
}

实际使用时可采用java自身的iterator特性，例子里的数组无法使用。 

总结 ： 

             -- 迭代器允许访问聚合的元素，而不需要暴露它的内部结构

             -- 迭代器将遍历聚合的工作封装进一个对象中。

             -- 当使用迭代器的时候，我们依赖聚合提供遍历。

             -- 迭代器提供了一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态机制。

             -- 我们应该努力让一个类只分配一个责任（设计原则）。

现在希望能够加一分餐后甜点的“子菜单”，则需要重新设计（组合模式）。