设计模式之九：迭代器与组合模式

迭代器模式：

有许多方法可以把对象堆起来成为一个集合（Collection），比如放入数组、堆栈或散列表中。若用户直接从这些数据结构中取出对象，则需要知道具体是存在什么数据结构中（如栈就用peek，数组[]）。迭代器能够让客户遍历你的对象而又无法窥视你存储对象的方式。

对象村餐厅和煎饼屋合并了，它们有着不同的菜单列表，但菜单项基础都是一样的。

class MenuItem
{
private:
	string name;
	string description;
	bool vegetarian;
	double price;

public:
	MenuItem(string name, string description, bool vegetarian, double price)
	{
		this->name = name;
		this->description = description;
		this->vegetarian = vegetarian;
		this->price = price;
	}

	string getName()
	{
		return name;
	}

	string getDescription()
	{
		return description;
	}

	bool isVegetarian()
	{
		return vegetarian;
	}

	double getpPrice()
	{
		return price;
	}
};

下面就写Java代码了，改成C++一时半会还是做不过来。

public class PancakeHouseMenu
{
	ArrayList menuItems;

	public PancakeHouseMenu()
	{
		menuItems = new ArrayList();

		addItem("K&B's Pancake Breakfast", "Pancakes with scrambled eggs, and toast", true, 2.99);
	}

	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 class DinerMenu
{
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	public DinerMenu()
	{
		menuItems = new MenuItem[MAX_ITEMS];

		addItem("Vegetarian BLT", "Fakin Bacon", true, 2.99);
	}

	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.println("Sorry, menu is full! Can't add item to menu");
		}
		else
		{
			menuItems[numberOfItems++] = menuItem;
		}
	}

	public MenuItem[] getMenuItems()
	{
		return menuItems;
	}
};

这两种不同的菜单表现方式，会使得女招待需要知道菜单的实现细节，才能对菜单进行遍历。

PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
ArrayList breakfastItems = pancakeHouseMenu.getMenuItems();

for breakfastItems.size()
MenuItem menuItem = (MenuItem)breakfastItems.get(i);


/ ******************************************************************* /
DinerMenu dinerMenu = new DinerMenu();
MenuItem[] lunchItems = DinerMenu.getMenuItems();

for lunchItems.size()
MenuItem menuItem = lunchItems[i];

如果还有第三家餐厅以不同的实现出现，我们就需要有三个循环。

因此，我们需要创建一个对象（迭代器），封装“遍历集合内的每个对象的过程”。

Iterator iter = breakfastItems.createIterator();

while (iter.hasNext())
{
	MenuItem menuItem = (MenuItem)iter.next();
}

 当我们拥有迭代器接口后，我们就可以为各种对象集合实现迭代器

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

public class DinerMenuIterator implements Iterator
{
	MenuItem[] items;
	int position = 0;

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

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

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

有了DinerMenuIterator后就可以改造DinerMenu和PancakeHouseMenu。

public class DinerMenu
{
	static final int MAX_ITEMS = 6;
	int numberOfItems = 0;
	MenuItem[] menuItems;

	// public DinerMenu()

	// addItem()

	// 删除getMenuItems()
    
    public Iterator createIterator()
    {
        // 返回迭代器接口。客户不需要知道餐厅菜单如何维护菜单项
        return new DinerMenuIterator(menuItems);
    }
};

public class Waitress {
	PancakeHouseMenu pancakeHouseMenu;
	DinerMenu dinerMenu;
 
	public Waitress(PancakeHouseMenu pancakeHouseMenu, DinerMenu dinerMenu) {
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinerMenu = dinerMenu;
	}
 
	public void printMenu() {
		Iterator pancakeIterator = pancakeHouseMenu.createIterator();
		Iterator dinerIterator = dinerMenu.createIterator();

		System.out.println("MENU\n----\nBREAKFAST");
		printMenu(pancakeIterator);
		System.out.println("\nLUNCH");
		printMenu(dinerIterator);

	}
 
	private void printMenu(Iterator iterator) {
		while (iterator.hasNext()) {
			MenuItem menuItem = iterator.next();
			System.out.print(menuItem.getName() + ", ");
			System.out.print(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}
}

现在可以进一步对waitress进行优化，因为她还捆绑两个具体的菜单类。但在优化之前，我们先看下目前的设计。

 除了使用自己构建的迭代器接口外，还可以直接使用java.util的迭代器接口，同时ArrayList也有一个返回迭代器的方法。

// 煎饼屋的代码

public Iterator createIterator()
{
    return menuItems.iterator();
}


// 餐厅的代码

public class DinerMenuIterator implements Iterator {
	MenuItem[] list;
	int position = 0;
 
	public DinerMenuIterator(MenuItem[] list) {
		this.list = list;
	}
 
	public MenuItem next() {
		MenuItem menuItem = list[position];
		position = position + 1;
		return menuItem;
	}
 
	public boolean hasNext() {
		if (position >= list.length || list[position] == null) {
			return false;
		} else {
			return true;
		}
	}

	public void remove() {
		if (position <= 0) {
			throw new IllegalStateException
				("You can't remove an item until you've done at least one next()");
		}
		if (list[position-1] != null) {
			for (int i = position-1; i < (list.length-1); i++) {
				list[i] = list[i+1];
			}
			list[list.length-1] = null;
		}
	}

}

最后我们再给菜单一个共同的接口，然后修改下女招待。

public interface Menu
{
    public Iterator createIterator();
}


public class Waitress {
	Menu pancakeHouseMenu;
	Menu dinerMenu;
 
	public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinerMenu = dinerMenu;
	}
 
	public void printMenu() {
		Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
		Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();

		System.out.println("MENU\n----\nBREAKFAST");
		printMenu(pancakeIterator);
		System.out.println("\nLUNCH");
		printMenu(dinerIterator);
	}
 
	private void printMenu(Iterator iterator) {
		while (iterator.hasNext()) {
			MenuItem menuItem = (MenuItem)iterator.next();
			System.out.print(menuItem.getName() + ", ");
			System.out.print(menuItem.getPrice() + " -- ");
			System.out.println(menuItem.getDescription());
		}
	}

}

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。（把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所）

单一职责：一个类应该只有一个引起变化的原因。（随着系统的成长，随时观察有没有迹象显示某个类改变的原因超出一个）

组合模式：

是现在我们有一个新的需求，将一份甜点菜单作为餐厅菜单的菜单项（而不是做成一个新菜单，因为类型不同）

（我们需要更有弹性的在菜单项之间游走，可能只需要遍历甜点菜单或者可以遍历餐厅的整个菜单。）

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

菜单是节点，菜单项是叶节点。

使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句话说，在大多数情况下，我们可以忽略对象组合和个别对象之间的差别。

菜单组件的角色是为叶节点和组合节点提供一个共同的接口（所有组件都必须实现MenuComponent接口，然而，叶节点和组合节点的角色不同，所以有些方法可能并不适合某些节点。面对这种情况，你最好是抛出运行时异常。这样如果菜单项或菜单不支持某个操作，他们就不需做任何事情，直接继承默认实现）。

组合模式以单一职责设计原则换取透明性。什么是透明性？通过让组件接口同时包含一些管理子节点和叶节点的操作，客户酒可以将组合和叶节点一视同仁。也就是说，一个元素究竟是组合还是叶节点，对客户是透明的。

上面代码先看next逻辑，清楚后再看hasNext（从上层往下层打印）

当你有数个对象的集合，它们彼此之间有“整体/部分”的关系，并且你想用一致的方法对待这些对象时，就可以使用组合模式。