设计模式——10 迭代器模式

10 Iterator Pattern（迭代器模式）

         前言：帮助客户用同样的方法遍历不同的集合。

需求：

         由于海岸城的店租极具增长，Vander的Pizza店和烧烤店需要合并在一起了，合并在一起，这两家店的主厨A和主厨B，他们的菜单实现却不相同，Pizza店的菜单是使用List，而烧烤店的菜单用的却是数组，让我们先来看看他们菜单的实现。

         首先两个主厨都是使用了MenuItem来写自己的菜单的。

MenuItem：

public class MenuItem {

	private String name;
	
	private String desc;
	
	private double price;

	public MenuItem(String name, String desc, double price) {
		super();
		this.name = name;
		this.desc = desc;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}
	
}

PizzaMenu：

public class PizzaMenu {

	private ArrayList<MenuItem> menuItem;
	
	public PizzaMenu() {
		menuItem = new ArrayList<MenuItem>();
		menuItem.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		menuItem.add(new MenuItem("BuffPizza", "American Style", 28.0));
		menuItem.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
	}
	
	public void addItem(MenuItem iterm) {
		menuItem.add(iterm);
	}

	public ArrayList<MenuItem> getMenuItem() {
		return menuItem;
	}

	public void setMenuItem(ArrayList<MenuItem> menuItem) {
		this.menuItem = menuItem;
	}
	
}

 BarbecueMenu：

public class BarbecueMenu {

	private static final int MAX_ITEMS = 5;
	
	private int numberOfIterms = 0;
	
	private MenuItem[] menuItems;
	
	public BarbecueMenu() {
		menuItems = new MenuItem[MAX_ITEMS];
		addItem(new MenuItem("chicken", "with pepper", 10));
		addItem(new MenuItem("tofu", "with pepper", 5));
		addItem(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
	}
	
	public void addItem(MenuItem menuItem) {
		if(numberOfIterms >= MAX_ITEMS) {
			System.err.println("sorry, menu is full!");
		} else {
			menuItems[numberOfIterms] = menuItem;
			numberOfIterms = numberOfIterms + 1;
		}
	}
	
}

 从代码可以看出，PizzaMenu是用List结构来存放菜单项目的，而BarbecueMenu则是用数组来存放菜单项目的。Vander作为老板又是他大显神威的时候了，他需要做一个菜单综合显示平台，显示出PizzaMenu和BarbecueMenu。我们来看看Vander的实现：

public class MenuAdmin {

	private BarbecueMenu barbecueMenu;

	private PizzaMenu pizzaMenu;

	public MenuAdmin(BarbecueMenu barbecueMenu, PizzaMenu pizzaMenu) {
		super();
		this.barbecueMenu = barbecueMenu;
		this.pizzaMenu = pizzaMenu;
	}

	public void displayMenu() {
		MenuItem[] barbecueItems = barbecueMenu.getMenuItems();
		ArrayList<MenuItem> pizzaItems = pizzaMenu.getMenuItem();
		for (int i = 0; i < barbecueItems.length; i++) {//数组的大小为5
			if(barbecueItems[i] != null) {
				System.out.println("name:" + barbecueItems[i].getName() + "-desc:" + barbecueItems[i].getDesc()
						+ "-price:" + barbecueItems[i].getPrice());
			}
		}
		
		for(MenuItem item : pizzaItems) {
			System.out.println("name:" + item.getName() + "-desc:" + item.getDesc()
					+ "-price:" + item.getPrice());
		}

	}

}

 实现效果：

 

Vander这么设计真的好吗？

1、MenuAdmin是不是直接针对PizzaMenu跟BarbecueMenu进行编码的，而不是针对接口编程。

2、如果又加入了日式料理菜单，而菜单是用HashMap实现的，岂不是又得需要修改很多MenuAdmin的代码。

3、MenuAdmin直接关心了PizzaMenu和BarbecueMenu的内部实现了，违反了封装原则。

4、displayMenu部分有重复代码，有两个类似的循环，如果加入第三个菜单又需要多一个循环。

Panda大师一看，又是糟糕的设计，Vander你就不能找一个迭代器来遍历这些数据吗，不同的数据结构实现不同的迭代器，MenuAdmin只需要用同样的循环就可以遍历这些菜单项了。接着Panda开始写迭代器（Iterator接口）。

Iterator（迭代器）接口：

public interface Iterator<T> {

	/**
	 * 判断集合是否有下一项
	 * @return
	 */
	boolean hasNext();
	
	/**
	 * 获取集合的下一项
	 * @return
	 */
	T next();
	
}

BarbecueMenuIterator：

public class BarbecueMenuIterator implements Iterator<MenuItem> {

	private MenuItem[] menuItems;
	
	private int position = 0;
	
	public BarbecueMenuIterator(MenuItem[] menuItems) {
		super();
		this.menuItems = menuItems;
	}

	public boolean hasNext() {
		if(position >= 0 && menuItems[position] != null) {
			return true;
		}
		return false;
	}

	public MenuItem next() {
		if(position >= 0 && menuItems[position] != null) {
			MenuItem item = menuItems[position];  
			position++;
			return item;
		}
		return null;
	}

}

 PizzaMenuIterator：

public class PizzaMenuIterator implements Iterator<MenuItem> {

	private ArrayList<MenuItem> menuItems;
	
	private int position = 0;
	
	public PizzaMenuIterator(ArrayList<MenuItem> menuItems) {
		super();
		this.menuItems = menuItems;
	}

	public boolean hasNext() {
		if(position < menuItems.size() && menuItems.get(position) != null) {
			return true;
		}
		return false;
	}

	public MenuItem next() {
		if(position < menuItems.size() && menuItems.get(position) != null) {
			MenuItem item = menuItems.get(position);  
			position++;
			return item;
		}
		return null;
	}

}

 BarbecueMenu：

public class BarbecueMenu {

	private static final int MAX_ITEMS = 5;
	
	private int numberOfIterms = 0;
	
	private MenuItem[] menuItems;
	
	public BarbecueMenu() {
		menuItems = new MenuItem[MAX_ITEMS];
		addItem(new MenuItem("chicken", "with pepper", 10));
		addItem(new MenuItem("tofu", "with pepper", 5));
		addItem(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
	}
	
	public void addItem(MenuItem menuItem) {
		if(numberOfIterms >= MAX_ITEMS) {
			System.err.println("sorry, menu is full!");
		} else {
			menuItems[numberOfIterms] = menuItem;
			numberOfIterms = numberOfIterms + 1;
		}
	}

	public Iterator<MenuItem> creatIterator() {
		BarbecueMenuIterator barbecueMenuIterator = new BarbecueMenuIterator(menuItems);
		return barbecueMenuIterator;
	}

	public void setMenuItems(MenuItem[] menuItems) {
		this.menuItems = menuItems;
	}
	
}

 MenuAdmin：

public class MenuAdmin {

	private BarbecueMenu barbecueMenu;

	private PizzaMenu pizzaMenu;

	public MenuAdmin(BarbecueMenu barbecueMenu, PizzaMenu pizzaMenu) {
		super();
		this.barbecueMenu = barbecueMenu;
		this.pizzaMenu = pizzaMenu;
	}
	
	public void displayMenus() {
		traverseMenus(barbecueMenu.creatIterator());
		traverseMenus(pizzaMenu.createIterator());
	}
	
	public void traverseMenus(Iterator<MenuItem> iterator) {
		while(iterator.hasNext()) {
			MenuItem menuItem = iterator.next();
			System.out.println("name:" + menuItem.getName() + "-desc:" + menuItem.getDesc()
					+ "-price:" + menuItem.getPrice());
		}
	}
	
}

 下面是迭代器实现的基础类图：

 

这里可能会有几个问题：

         1、能不能直接用BarbecueMenu直接实现迭代器接口？

         答案是可以的，但是代码侵入性太大，我们要保证原有类不进行太大的变动，再说了厨师们也不喜欢你乱搞。

         2、MenuAdmin中的两个属性能不能直接是两个菜单对应的迭代器？

   答案也是可以的，但是这样虽然实现上没有问题，但是迭代器作为较为低层的部分，这么做在逻辑上说不过去，本来菜单管理的类里面就应该是菜单管理的，突然属性变成了迭代器，这就有点奇怪了。

 

分析：

实际上当前的MenuAdmin依然是针对实现编程的，PizzaMenu和BarbecueMenu都有createIterator方法，所以可以定义一个Menu接口，java.util中的ArrayList实际上已经帮我们实现了Iterator了，我们直接用就可以了。接下来，进行下一步改造。

我们首先删除我们自己定义的Iterator接口和PizzaMenuIterator（由于ArrayList本身就有迭代器实现），然后import进java.util.Iterator接口，然后将MenuAdmin中的实现改成接口，改写PizzaMenu类中的createIterator方法就完成了。

Menu：

public interface Menu<T> {

	/**
	 * 创建迭代器
	 * @return
	 */
	Iterator<T> createIterator();
	
}

PizzaMenu：

public class PizzaMenu implements Menu<MenuItem> {

	private ArrayList<MenuItem> menuItems;
	
	public PizzaMenu() {
		menuItems = new ArrayList<MenuItem>();
		menuItems.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		menuItems.add(new MenuItem("BuffPizza", "American Style", 28.0));
		menuItems.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
	}
	
	public void addItem(MenuItem menuIterm) {
		menuItems.add(menuIterm);
	}

	public Iterator<MenuItem> createIterator() {
		Iterator<MenuItem> menuItemIterator =  menuItems.iterator();
		return menuItemIterator;
	}

	public void setMenuItem(ArrayList<MenuItem> menuItems) {
		this.menuItems = menuItems;
	}
	
}

MenuAdmin：

public class MenuAdmin {

	private Menu<MenuItem> barbecueMenu;

	private Menu<MenuItem> pizzaMenu;

	public MenuAdmin(Menu<MenuItem> barbecueMenu, Menu<MenuItem> pizzaMenu) {
		super();
		this.barbecueMenu = barbecueMenu;
		this.pizzaMenu = pizzaMenu;
	}
	
	public void displayMenus() {
		traverseMenus(barbecueMenu.createIterator());
		traverseMenus(pizzaMenu.createIterator());
	}
	
	public void traverseMenus(Iterator<MenuItem> iterator) {
		while(iterator.hasNext()) {
			MenuItem menuItem = iterator.next();
			System.out.println("name:" + menuItem.getName() + "-desc:" + menuItem.getDesc()
					+ "-price:" + menuItem.getPrice());
		}
	}	

}

 

分析：

         这么写之后有什么好处呢：

1、MenuAdmin不再针对于实现编程，而是针对接口（Menu）编程，减少了其对具体类的依赖。

2、每个菜单都要求要实现Menu接口，所以每个菜单必须提供createIterator方法，让菜单管理类能够获得Iterator。MenuAdmin类也不需要关心每个菜单内部用了什么结构去存储数据，只需要用迭代器的方法就能完成遍历。

        

下面我们隆重有请迭代器模式登场：

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的实现。迭代器模式把元素之间的游走的责任交给迭代器，而不是聚合对象，这不仅让聚合的接口和实现变得更简洁，也可以让聚合更专注在它所应该专注的事情（也就是管理对象集合），而不必去理会遍历的事情。

         迭代器的套路如下图所示，这里的Client对应MenuAdmin，ConcreteInterator对应PizzaMenuIterator和BarbecueMenuIterator，Aggregate对应Menu接口，ConcreteAggregate对应PizzaMenu和BarbecueMenu。

 

这里简单说明一下聚合对象，首先当我们说集合的时候，是指一群对象，其存储方式可以是各种各样的数据结构，例如列表、数组、散列表，有时候集合也会叫做聚合。

 

还记得我们刚刚讨论的吗，为什么不直接用PizzaMenu来实现Iterator接口然后实现遍历集合的这些方法？

当你这么做之后，就会发现PizzaMenu不仅仅要维护MenuItems这个集合，还要承担遍历这个集合的责任，这样的话，这个集合改变，MenuItem就必须改变，若遍历的方式改变，这个集合又要改变，这样它就承担了两种变化的风险了。根据这个理念，我们引入了单一变化原则来说明这件事情。

单一变化原则：一个类应该只有一个引起变化的原因。

类的每一个责任都有改变的潜在区域。超过一个责任，意味着超过一个改变的区域。这个原则告诉我们尽量让每个类保持“单一责任”。

高内聚低耦合是我们经常听到的，内聚是用来度量一个类或一个模块紧密地达到单一目的或责任。当一个类或模块被设计成只支持一组相关地功能时，我们说它具有高内聚；反之，当被设计成支持一组不相关地功能时，我们说它具有低内聚。内聚是一个比单一责任更加普遍的概念，但两者关系密切，遵守这原则的类容易具有很高的凝聚力，比低内聚的类容易维护得多。

Vander在欢乐海岸的火锅店的店租也越来越贵了，近两个月甚至已经入不敷出了，所以它决定扩大pizza店的店面，加入烧烤之后再加入火锅，这样让客人有更多地选择，可惜地是厨师C的自助火锅店的菜单又是用另一种数据结构来完成的，不要紧，现在采用的系统已经具有一定的扩展性了。接下来添加火锅店的Menu的。

HotPotMenu：

public class HotPotMenu implements Menu<MenuItem>{

	private Map<String, MenuItem> itemMap; 
	
	public HotPotMenu(){
		itemMap = new HashMap<String, MenuItem>();
		itemMap.put("lotus root", new MenuItem("lotus root", "with salt", 10));
		itemMap.put("tofu", new MenuItem("tofu", "with salt", 5));
		itemMap.put("potatos", new MenuItem("potatos", "with salt", 10));
	}
	
	public Iterator<MenuItem> createIterator() {
		HotPotMenuIterator hotPotMenuIterator = new HotPotMenuIterator(itemMap);
		return hotPotMenuIterator;
	}

}

 HotPotMenuIterator：

public class HotPotMenuIterator implements Iterator<MenuItem>  {

	private Map<String, MenuItem> itemMap; 
	
	private Iterator<String> itemSetIterator;
	
	public HotPotMenuIterator(Map<String, MenuItem> itemMap) {
		this.itemMap = itemMap;
		itemSetIterator = itemMap.keySet().iterator();
	}
	
	public boolean hasNext() {
		if(itemSetIterator.hasNext()) {
			return true;
		}
		return false;
	}

	public MenuItem next() {
		MenuItem menuItem = itemMap.get(itemSetIterator.next());
		return menuItem;
	}

}

 每次加入新的菜单，MenuAdmin都需要添加新的Menu，并且还要添加多一句遍历新菜单的语句。我们将其进一步进行改进。

MenuAdmin：

public class MenuAdmin {

	private List<Menu<MenuItem>> menuList;

	public MenuAdmin(List<Menu<MenuItem>> menuList) {
		this.menuList = menuList;
	}
	
	public void displayMenus() {
		for(Menu<MenuItem> menu : menuList) {
			traverseMenus(menu.createIterator());
		}
	}
	
	public void traverseMenus(Iterator<MenuItem> iterator) {
		while(iterator.hasNext()) {
			MenuItem menuItem = iterator.next();
			System.out.println("name:" + menuItem.getName() + "-desc:" + menuItem.getDesc()
					+ "-price:" + menuItem.getPrice());
		}
	}
	
}

最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。

面向对象基础

         抽象、封装、多态、继承

八大设计原则

设计原则一：封装变化

设计原则二：针对接口编程，不针对实现编程。

         设计原则三：多用组合，少用继承。

         设计原则四：为交互对象之间的松耦合设计而努力

设计原则五：对扩展开放，对修改关闭

设计原则六：依赖抽象，不要依赖于具体的类

设计原则七：只和你的密友谈话

设计原则八：别找我，我有需要会找你

设计原则九：类应该只有一个改变的理由

模式

迭代器模式：提供一个方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的实现。

最后献上此次设计所涉及到的源码，有需要的小伙伴可以下载来运行一下，首先先自己进行设计，然后再参考，这样才能加深模式的理解。