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

迭代器模式

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

迭代器模式把在元素之间游走的责任交给了迭代器，而不是聚合对象。这不仅让聚合的接口和实现变得更简洁，也可以让聚合更专注在它所应该专注的事情上面（也就是管理对象集合），而不必去理会遍历的事情。

下面是具体例子：

菜单项的类：MenuItem.java

package com.designpattern.iterator;

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 boolean isVegetarian() {
return vegetarian;
}

public double getPrice() {
return price;
}

}

菜单的共同接口(用于返回迭代器)：Menu.java

package com.designpattern.iterator;

import java.util.Iterator;

/**
* 菜单的共同接口
* */
public interface Menu {
public Iterator<?> createIterator();
}

建立两个菜单：PancakeHouseMenu.java & DinerMenu.java，都实现Menu接口

package com.designpattern.iterator;

import java.util.ArrayList;
import java.util.Iterator;

/**
* 用ArrayList来存储菜单项，有内嵌的返回迭代器方法，menuItems.iterator()；
* createIterator()方法中可以直接返回迭代器，不用自己写迭代器；
* */
public class PancakeHouseMenu implements Menu{
ArrayList<MenuItem> menuItems;

public PancakeHouseMenu(){
menuItems = new ArrayList<MenuItem>();

addItem("K&B's 薄煎饼早餐", "薄煎饼、清蛋和吐司", true, 2.99);
addItem("薄煎饼早餐例餐", "薄煎饼带煎蛋，香肠", false, 2.99);
addItem("蓝莓薄煎饼", "新鲜蓝莓和蓝莓糖浆做成的薄煎饼", true, 3.49);
addItem("松饼", "松饼，可以选择蓝莓或草莓", 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<MenuItem> getMenuItems(){
//		return menuItems;
//	}

@Override
public Iterator<MenuItem> createIterator() {
// TODO Auto-generated method stub
return menuItems.iterator();
}

}

package com.designpattern.iterator;

import java.util.Iterator;

/**
* 用数组来存储菜单项，没有内嵌的返回迭代器方法；
* 需要自己写迭代器：DinerMenuIterator.java，继承自Iterator类。
* */
public class DinerMenu implements Menu{
static final int MAX_ITEMS = 6;
int numberOfItems = 0;
MenuItem[] menuItems;

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

addItem("素食BLT", "（煎）培根、生菜&西红柿，用麦皮面包做", true, 2.99);
addItem("BLT", "培根、生菜&西红柿", false, 2.99);
addItem("例汤", "一碗例汤，配土豆沙拉", false, 3.29);
addItem("热狗", "热狗、酸菜、上盖芝士", 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.println("Sorry, menu is full! Can't add item to menu.");
}else{
menuItems[numberOfItems] = menuItem;
numberOfItems +=1;
}
}

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

@Override
public Iterator<Object> createIterator() {
// TODO Auto-generated method stub
return new DinerMenuIterator(menuItems);
}
}

DinerMenu.java中用到的返回迭代器的类：DinerMenuIterator.java

package com.designpattern.iterator;

import java.util.Iterator;

/**
* 由于数组没有内嵌的返回迭代器的方法，因此需要写自己的迭代器；
* */
public class DinerMenuIterator implements Iterator<Object>{
MenuItem[] list;
int position = 0;

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

@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if(position >= list.length || list[position] == null){
return false;
}else{
return true;
}
}

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

@Override
public void remove() {
// TODO Auto-generated method stub
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;
}
}

}

具体操作菜单的类：Waitress.java

package com.designpattern.iterator;

import java.util.Iterator;

/**
* 操作菜单的类
* */
public class Waitress {
Menu pancakeHouseMenu;
Menu dinerMenu;

public Waitress(Menu pancakeHouseMenu, Menu 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 = (MenuItem) iterator.next();
System.out.println(menuItem.getName() + ",");
System.out.println(menuItem.getPrice() + "---");
System.out.println(menuItem.getDescription());
}
}
}

测试类：Test.java

package com.designpattern.iterator;

public class Test {
public static void main(String[] args) {
Menu pancakeHouseMenu = new PancakeHouseMenu();
Menu dinerMenu = new DinerMenu();

Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
waitress.printMenu();
}
}

小结：
两个菜单都实现了Menu接口，Waitress类可以直接利用接口引用每一个菜单对象。这样通过“针对接口编程，而不是针对实现编程”，我们就可以减少Waitress类与具体类之间的依赖。

此外，如果想要再添加新的菜单也会变得很容易，只需要按照前面两个菜单类写一个继承Menu接口的菜单类，再在Waitress类中添加菜单类的对象即可。即Waitress类具有更好的扩展性。

JAVA 5包含了一种新形式的for语句，称for/in。这可以让你在一个集合或者一个数组中遍历，而且不需要显式创建迭代器。但需要使用JAVA 5的泛型新特性来确保for/in的类型安全。

但是，迭代器模式还存在一个问题，假如想在菜单中添加子菜单，迭代器模式是不可以实现的，这要用到接下来要将的“组合模式”。