设计模式 —— 迭代器模式（Iterator Pattern）

迭代器模式（Iterator Pattern）

概念：

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

---

迭代器模式是一种简单常见的设计模式，在我们使用编程语言中的集合容器都会有迭代器。

---

组成：

Aggregate（抽象聚合）：共同的接口供所有的聚合使用。

ConcreteAggregate（聚合）：持有一个对象的集合，并实现 createIterator 方法，返回集合的迭代器。

Iterator（抽象迭代器接口）：包含所有迭代器都必须实现的方法。

ConcreteIterator（具体迭代器）：实现了迭代器接口的具体迭代器。

---

例子：

现有两家超市，一家为水果超市，一家为零食超市。他们分别请了两位编程人员帮他们实现打印品种清单程序。结果第一家编程人员用数组集合来存储不同的水果，第二家编程人员用 ArrayList 集合来存储零食种类。如下：

物品类：

public class Item {    private String name;    private String description;    double price;    public Item(String name, String description, double price) {        this.name = name;        this.description = description;        this.price = price;    }    public String getName() {        return name;    }    public String getDescription() {        return description;    }    public double getPrice() {        return price;    }}

---

水果超市类：

public class FruitSupermarket {    ArrayList menuItems;    public FruitSupermarket() {        menuItems = new ArrayList();        //添加水果        addItem("苹果", "红色的", 1.99);        addItem("香蕉", "黄色的", 2.00);        addItem("橙子", "横色的", 3.12);    }    public void addItem(String name, String description, double price) {        Item item = new Item(name, description, price);        menuItems.add(item);    }    public ArrayList getMenuItems() {        return menuItems;    }}

---

零食超市类：

public class SnacksSupermarket {    static final int MAX_ITEMS = 6;    int numberOfItems = 0;    Item[] menuItems;    public SnacksSupermarket() {        menuItems = new Item[MAX_ITEMS];        //添加零食        addItem("牛奶", "伊利", 2.24);        addItem("糖", "阿尔卑斯", 5.12);        addItem("巧克力", "金蒂", 1.23);    }    public void addItem(String name, String description, double price) {        Item item = new Item(name, description, price);        if (numberOfItems >= MAX_ITEMS) {            System.out.println("抱歉，清单已满...");        } else {            menuItems[numberOfItems] = item;            numberOfItems += 1;        }    }    public Item[] getMenuItems() {        return menuItems;    }}

现在假设两家超市合并了，我们要遍历两家超市的清单。

public class Supermarket {    FruitSupermarket fruitSupermarket;    SnacksSupermarket snacksSupermarket;    public Supermarket() {        fruitSupermarket = new FruitSupermarket();        snacksSupermarket = new SnacksSupermarket();    }    //遍历菜单方法，内部分别包含两家超市的遍历。    public void printMenu() {        ArrayList fruitItems = fruitSupermarket.getMenuItems();        Item[] snacksItems = snacksSupermarket.getMenuItems();        //遍历水果超市        System.out.println("fruitItem:");        for (int i = 0; i < fruitItems.size(); ++i) {            Item item = (Item) fruitItems.get(i);            System.out.print("name:" + item.getName());            System.out.print(" description:" + item.getDescription());            System.out.println(" price:" + item.getPrice());        }        //遍历零食超市        System.out.println("\nsnacksItem:");        for (int i = 0; i < snacksSupermarket.getNumberOfItems(); ++i) {            Item item = snacksItems[i];            System.out.print("name:" + item.getName());            System.out.print(" description:" + item.getDescription());            System.out.println(" price:" + item.getPrice());        }    }    public static void main(String[] args) {        Supermarket supermarket = new Supermarket();        supermarket.printMenu();    }}

---

如果将来再次合并超市又必须修改代码，增加一个循环，我们可以发现上述代码成了 面向实现 编程而不是 面向接口。
我们来通过 迭代器模式 改进这个类。

---

先将两个超市类增加 createIterator() 方法，返回内部集合的迭代器。

由于 ArrayList 本身有迭代器，我们直接返回即可。

    //省略原本类的方法    public Iterator createIterator() {        return menuItems.iterator();    }

但零食超市中的数组集合没有迭代器，我们自己实现一个。

//Java 提供了迭代器接口，我们直接实现即可public class SnacksIterator implements Iterator {    Item[] menuItems;    int position = 0;    public SnacksIterator(Item[] menuItems) {        this.menuItems = menuItems;    }    //判断是否有下一个元素方法    public boolean hasNext() {        if (position >= menuItems.length || menuItems[position] == null) {            return false;        }else {            return true;        }    }    //返回下一个对象方法    public Object next() {        Item menuitem = menuItems[position];        position += 1;        return menuitem;    }}

    //...省略原本类和方法    public Iterator createIterator() {        return new SnacksIterator(menuItems);    }

---

超市类：

public class Supermarket {    FruitSupermarket fruitSupermarket;    SnacksSupermarket snacksSupermarket;    public Supermarket() {        fruitSupermarket = new FruitSupermarket();        snacksSupermarket = new SnacksSupermarket();    }    //由于实现了统一的接口，再次添加我们继续创建对应的迭代器类，加入 printMenu 即可。    public void printMenu() {        //我们也可以将所有的清单加入集合中，这样下面的代码也不用改变了。        Iterator fruitIterator = fruitSupermarket.createIterator();        Iterator snacksIterator = snacksSupermarket.createIterator();        System.out.println("FruitSupermarket");        printMenu(fruitIterator);        System.out.println("\nSnacksSupermarket");        printMenu(snacksIterator);    }    private void printMenu(Iterator iterator) {        while (iterator.hasNext()) {            Item item = (Item) iterator.next();            System.out.print("name:" + item.getName());            System.out.print(" description:" + item.getDescription());            System.out.println(" price:" + item.getPrice());        }    }    public static void main(String[] args) {        Supermarket supermarket = new Supermarket();        supermarket.printMenu();    }}

---

适用场景：

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 需要为聚合对象提供多种遍历方式。
• 为遍历不同的聚合结构提供一个统一的接口 (即, 支持多态迭代)

---

补充：设计原则

单一设计原则：一个类应该只有一个引起变化的原因
我们应该避免类内的改变，因为修改代码很容易造成许多潜在的错误。如果一个类具有两个改变的原因，那么类变化的几率就很大了，并且当它真的改变时，我们的设计中会有两方面受到影响。

当一个模块或一个类被设计成只支持一组相关的功能时，我们说它具有高内聚。反之，当被设计成支持一组不相关的功能时，我们说它具有低内聚。