设计模式之迭代器模式

迭代器模式定义

迭代器模式定义：提供一种方法顺序访问一个聚合对象中的各个对象。

迭代模式使用场景

(1)访问一个聚合对象的内容而无需暴露它的内部表示
(2)支持对聚合对象的多种遍历
(3)为遍历不同的聚合结构提供一个统一的接口

实际案例分析

有一个蛋糕店和一个餐厅要进行合并，这也意味着要将要将这两个店铺的菜单进行合并展示，如何从原有项目进行合并？从代码实现的角度要怎么设计？本文将从传统设计和迭代器模式两个角度进行说明。

1. 传统模式设计
   传统设计的思路是将蛋糕店类和餐厅类分别提供返回自身菜单数据集合的方法，然后在其服务员类获取菜单集合遍历展示显示，实现代码如下：

蛋糕店菜单类:通过List保存菜单，并提供了getMenuItems方法返回集合数据，暴露了其数据结构。

public class CakeHouseMenu {
	private ArrayList<MenuItem> menuItems;

	public CakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		
		addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
		addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
		addItem("Stawberry Cake","fresh stawberry",true,3.29f);
		addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		menuItems.add(menuItem);
	}
	public ArrayList<MenuItem> getMenuItems() {
		return menuItems;
	}
	
	//其他功能代码
}

菜单实体类：包含菜品最基本的名称、描述信息。

public class MenuItem {
	private String name,description;
	private boolean vegetable;
	private float price;
	public MenuItem(String name,String description,boolean vegetable,float price)
	{
		this.name=name;
		this.description=description;
		this.vegetable=vegetable;
		this.price=price;
		
	}
	public String getName()
	{
		return name;
	}
	public String getDescription()
	{
		return description;
	}
	public float getPrice()
	{
		return price;
	}
	public boolean  isVegetable()
	{
		return vegetable;
	}
}

餐厅类实现如下：餐厅菜单数据是用数组形式保存，同时也提供了方法返回数据。

public DinerMenu()
{
	menuItems=new MenuItem[Max_Items] ;
	addItem("vegetable Blt","bacon&lettuce&tomato&cabbage",true,3.58f);
	addItem("Blt","bacon&lettuce&tomato",false,3.00f);
	addItem("bean soup","bean&potato salad",true,3.28f);
	addItem("hotdog","onions&cheese&bread",false,3.05f);
	
	
}
private void addItem(String name, String description, boolean vegetable,
		float price) {
	MenuItem menuItem = new MenuItem(name, description, vegetable, price);
	if(numberOfItems>=Max_Items)
	{
		System.err.println("sorry,menu is full!can not add another item");
	}else{
		menuItems[numberOfItems]=menuItem;
		numberOfItems++;
	}
	
}

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

服务员展示菜单类：

public class Waitress {
	private CakeHouseMenu mCakeHouseMenu;
	private DinerMenu mDinerMenu;
	private ArrayList<MenuItem> cakeitems;
	private MenuItem[] dineritems;

	public Waitress() {
		mCakeHouseMenu = new CakeHouseMenu();
		cakeitems = mCakeHouseMenu.getMenuItems();

		mDinerMenu = new DinerMenu();
		dineritems = mDinerMenu.getMenuItems();
	}

	public void printMenu() {
		MenuItem menuItem;
		for (int i = 0, len = cakeitems.size(); i < len; i++) {
			menuItem = cakeitems.get(i);
			System.out.println(menuItem.getName() + "***"
					+menuItem.getPrice()+"***"+ menuItem.getDescription());

		}
		for (int i = 0, len = mDinerMenu.numberOfItems; i < len; i++) {
			menuItem = dineritems[i];
			System.out.println(menuItem.getName() + "***"
					+menuItem.getPrice()+"***"+ menuItem.getDescription());

		}

	}

	public void printBreakfastMenu() {

	}

	public void printLunchMenu() {

	}

	public void printVegetableMenu() {

	}
}

服务员通过调用蛋糕店和餐厅返回的集合数据然后进行接收遍历展示。从传统设计的简单代码实现来看，这种设计有几个缺点。
（1） 扩展性较差。假如我需要新合并一个零食店，新增一个零食类提供暴露数据方法的同时，还要在服务员新增list去接收订单项并循环输出，从扩展性的设计角度上来说，一个类的修改是关闭的，扩展是开放的，即一个类的新增不会引起另一个类修改。另外，开发应该是针对于接口进行开发，而不是实现类

（2）蛋糕和餐厅的数据结构都是暴露的，在服务员类需要关注返回的数据结构，提高了类之间的耦合性，同时也会带来隐藏的安全问题。

2. 迭代器模式设计

首先我们设计一个迭代器接口，接口有两个方法，hasNext判断是否有下一条数据，next方法返回数据

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

}

在餐厅和蛋糕店菜单项内植入了迭代器接口的实现类。

public class DinerMenu {
	private final static int Max_Items = 5;
	private int numberOfItems = 0;
	private MenuItem[] menuItems;

	public DinerMenu() {
		menuItems = new MenuItem[Max_Items];
		addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
		addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
		addItem("bean soup", "bean&potato salad", true, 3.28f);
		addItem("hotdog", "onions&cheese&bread", false, 3.05f);

	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		if (numberOfItems >= Max_Items) {
			System.err.println("sorry,menu is full!can not add another item");
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems++;
		}

	}

	public Iterator getIterator() {
		return new DinerIterator();
	}

	class DinerIterator implements Iterator {
		private int position;

		public DinerIterator() {
			position = 0;
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			if (position < numberOfItems) {
				return true;
			}
			
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuItem menuItem = menuItems[position];
			position++;
			return menuItem;
		}
	};
}

通过实现迭代器接口，返回的是迭代器对象，没有将数据结构暴露出去。

public class CakeHouseMenu {
	private ArrayList<MenuItem> menuItems;
	
	
	public CakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		
		addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
		addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
		addItem("Stawberry Cake","fresh stawberry",true,3.29f);
		addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		menuItems.add(menuItem);
	}
	

	
	public Iterator getIterator()
	{
		return new CakeHouseIterator() ;
	}
	
	class CakeHouseIterator implements  Iterator
	 {		
		private int position=0;
		public CakeHouseIterator()
		{
			  position=0;
		}
		
		 	@Override
			public boolean hasNext() {
			// TODO Auto-generated method stub
			if(position<menuItems.size())
			{
				return true;
			}
			
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuItem menuItem =menuItems.get(position);
			position++;
			return menuItem;
		}};
	//其他功能代码
	
}

服务员类通过获取迭代器对象遍历菜单项展示

public class Waitress {
	private ArrayList<Iterator> iterators=new ArrayList<Iterator>();


	public Waitress() {
		
	}
	public void addIterator(Iterator iterator)
	{
		iterators.add(iterator);
		
	}
	public void printMenu() {
		Iterator iterator;
		MenuItem menuItem;
		for (int i = 0, len = iterators.size(); i < len; i++) {
			iterator = iterators.get(i);
			
			while(iterator.hasNext())
			{
				menuItem=(MenuItem)	iterator.next();
				System.out.println(menuItem.getName() + "***"
						+menuItem.getPrice()+"***"+ menuItem.getDescription());

			}
			
			
		}
		
		

	}

	public void printBreakfastMenu() {

	}

	public void printLunchMenu() {

	}

	public void printVegetableMenu() {

	}
}
 

相对于传统设计，迭代器设计模式的优点如下：

1. 避免了数据结构的暴露，降低耦合性
2. 可扩展性和可维护性好

迭代器模式的缺点

类的个数成对增加，在本例中新增了两个内部类去实现。