HeadFirst 設計模式學習筆記9--迭代器模式

1.本節的一個話題引子是一個餐廳，它提供早餐和午餐，但是在訂製菜單的時候，早餐（Pancake）和午餐（Dinner）的實現卻造成了一些麻煩。訂製早餐的菜單是用ArrayList這樣一個數據池來維護的。但是訂製午餐的菜單則是一個標準數組進行維護。那麼在設計訂餐程序來遍歷這兩個不同的數據結構形成的菜單的時候，就會比較麻煩，畢竟返回的數據類型不是一樣的。（不知道我說清楚了沒，參閱英文版原書P321）

2.對於這樣的迭代場景，我們就可以使用所謂迭代器模式。它依賴於一個名爲迭代器的接口，然後讓所有相關的部分（在這個例子就是兩個菜單的迭代器）實現該迭代器。提供了一種方法順序訪問一個聚合對象的各個元素，同時又不暴露其內部的表示。具體的，我們先加入一個迭代器：

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]; position = position + 1; return menuItem; } public boolean hasNext() { if (position >= items.length || items[position] == null) { return false; } else { return true; } } } public class PancakeHouseMenuIterator implements Iterator { ArrayList items; int position = 0; public PancakeHouseMenuIterator(ArrayList items) { this.items = items; } public Object next() { Object object = items.get(position); position = position + 1; return object; } public boolean hasNext() { if (position >= items.size()) { return false; } else { return true; } } }

 

通過上述實現接口的模式，我們把遊走的任務放在迭代器上，而不是具體聚合上，這樣既簡化了聚合的接口和實現，也讓責任各得其所。對於早餐和午餐的菜單，我們做如下的設計：

早餐：

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); addItem("Regular Pancake Breakfast", "Pancakes with fried eggs, sausage", false, 2.99); addItem("Blueberry Pancakes", "Pancakes made with fresh blueberries", true, 3.49); addItem("Waffles", "Waffles, with your choice of blueberries or strawberries", 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 getMenuItems() { return menuItems; } public Iterator createIterator() { return new PancakeHouseMenuIterator(menuItems); } public String toString() { return "Objectville Pancake House Menu"; } }  

午餐：

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 with lettuce & tomato on whole wheat", true, 2.99); addItem("BLT", "Bacon with lettuce & tomato on whole wheat", false, 2.99); addItem("Soup of the day", "Soup of the day, with a side of potato salad", false, 3.29); addItem("Hotdog", "A hot dog, with saurkraut, relish, onions, topped with cheese", false, 3.05); addItem("Steamed Veggies and Brown Rice", "Steamed vegetables over brown rice", true, 3.99); addItem("Pasta", "Spaghetti with Marinara Sauce, and a slice of sourdough bread", true, 3.89); } 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 = numberOfItems + 1; } } public MenuItem[] getMenuItems() { return menuItems; } public Iterator createIterator() { return new DinerMenuIterator(menuItems); } }

注意加粗的部分，我們加入了一個迭代器的工廠方法。此時，我們現在的服務生就可以從容的處理早餐和晚餐了：

public class Waitress { //原書中的第一個例子就是這麼寫的，而且它自己也指出了可以面向接口Menu編程，進行統一定義，不過不知道爲何它在第二個例子中才使用，其實在第一個例子中就直接面向接口將這些定義轉化爲Menu 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 = (MenuItem)iterator.next(); System.out.print(menuItem.getName() + ", "); System.out.print(menuItem.getPrice() + " -- "); System.out.println(menuItem.getDescription()); } } public void printVegetarianMenu() { printVegetarianMenu(pancakeHouseMenu.createIterator()); printVegetarianMenu(dinerMenu.createIterator()); } public boolean isItemVegetarian(String name) { Iterator breakfastIterator = pancakeHouseMenu.createIterator(); if (isVegetarian(name, breakfastIterator)) { return true; } Iterator dinnerIterator = dinerMenu.createIterator(); if (isVegetarian(name, dinnerIterator)) { return true; } return false; } private void printVegetarianMenu(Iterator iterator) { while (iterator.hasNext()) { MenuItem menuItem = (MenuItem)iterator.next(); if (menuItem.isVegetarian()) { System.out.print(menuItem.getName()); System.out.println("/t/t" + menuItem.getPrice()); System.out.println("/t" + menuItem.getDescription()); } } } private boolean isVegetarian(String name, Iterator iterator) { while (iterator.hasNext()) { MenuItem menuItem = (MenuItem)iterator.next(); if (menuItem.getName().equals(name)) { if (menuItem.isVegetarian()) { return true; } } } return false; } }

我們下兩個單試一試：

public class MenuTestDrive { public static void main(String args[]) { PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu(); DinerMenu dinerMenu = new DinerMenu(); Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu); waitress.printMenu(); } }

3.這樣看上去代碼是增加了不少，但是對於兩個本來寫好的類（PancakeHouseMenu和DinerMenu），我們只在其中加入了createIterator這個方法，系統的耦合性很低。此時女招待這個類就不需要知道菜單具體的實現了，並且實現迭代器後我們只需一個循環就可以遍歷了。

 

4.其實，Java中就有迭代器，我們將PancakeHouseMenu和DinerMenu所擴展的接口換成java.util的迭代器接口即可，連ArrayList也有一個返回一個迭代器的iterator方法。這樣可以進一步減少依賴。首先，我們不需要去創建Iterator接口，直接使用JAVA中的迭代器接口來構造DinerMenuIterator：

public class DinerMenuIterator implements Iterator { MenuItem[] list; int position = 0; public DinerMenuIterator(MenuItem[] list) { this.list = list; } public Object 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() {//注意，這個是Util.Iterator中要實現的方法 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; } }

注意：要是不想提供remove方法，那要怎麼辦呢？我們可以拋出一個UnsupportedOperationException異常表示不支持這樣的方法

public class AlternatingDinerMenuIterator implements Iterator { MenuItem[] items; int position; public AlternatingDinerMenuIterator(MenuItem[] items) { this.items = items; Calendar rightNow = Calendar.getInstance(); position = rightNow.DAY_OF_WEEK % 2; } public Object next() { MenuItem menuItem = items[position]; position = position + 2; return menuItem; } public boolean hasNext() { if (position >= items.length || items[position] == null) { return false; } else { return true; } } public void remove() { throw new UnsupportedOperationException( "Alternating Diner Menu Iterator does not support remove()"); } }

而PancakeHouseMenu 則不需要再實現，因爲ArrayList直接有返回迭代器的相應方法。

我們現在開始實現菜單，等等！！

我們發現在兩個菜單中有一個共同的方法createIterator，那麼在這我們又有一個新的改進——可以通過面向接口編程，使二者統一起來：

public interface Menu { public Iterator createIterator(); }

早餐：

public class PancakeHouseMenu implements Menu { ArrayList menuItems; public PancakeHouseMenu() { menuItems = new ArrayList(); addItem("K&B's Pancake Breakfast", "Pancakes with scrambled eggs, and toast", true, 2.99); addItem("Regular Pancake Breakfast", "Pancakes with fried eggs, sausage", false, 2.99); addItem("Blueberry Pancakes", "Pancakes made with fresh blueberries, and blueberry syrup", true, 3.49); addItem("Waffles", "Waffles, with your choice of blueberries or strawberries", 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 getMenuItems() { return menuItems; } public Iterator createIterator() { return menuItems.iterator();//這是我們唯一修改的部分，由於Arraylist直接對應得到其迭代器的方法，所以直接調用該方法即可。 } // other menu methods here }

晚餐：

public class DinerMenu implements Menu { static final int MAX_ITEMS = 6; int numberOfItems = 0; MenuItem[] menuItems; public DinerMenu() { menuItems = new MenuItem[MAX_ITEMS]; addItem("Vegetarian BLT", "(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99); addItem("BLT", "Bacon with lettuce & tomato on whole wheat", false, 2.99); addItem("Soup of the day", "Soup of the day, with a side of potato salad", false, 3.29); addItem("Hotdog", "A hot dog, with saurkraut, relish, onions, topped with cheese", false, 3.05); addItem("Steamed Veggies and Brown Rice", "A medly of steamed vegetables over brown rice", true, 3.99); addItem("Pasta", "Spaghetti with Marinara Sauce, and a slice of sourdough bread", true, 3.89); } 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 = numberOfItems + 1; } } public MenuItem[] getMenuItems() { return menuItems; } public Iterator createIterator() { return new DinerMenuIterator(menuItems); //return new AlternatingDinerMenuIterator(menuItems);//這裏你可以根據選擇使用要不要支持remove 的迭代器 } // other menu methods here }

我們針對這個實現，來創建的女招待代碼就變得更加鬆耦合：
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.print(menuItem.getName() + ", "); System.out.print(menuItem.getPrice() + " -- "); System.out.println(menuItem.getDescription()); } } public void printVegetarianMenu() { System.out.println("/nVEGETARIAN MENU/n----/nBREAKFAST"); printVegetarianMenu(pancakeHouseMenu.createIterator()); System.out.println("/nLUNCH"); printVegetarianMenu(dinerMenu.createIterator()); } public boolean isItemVegetarian(String name) { Iterator pancakeIterator = pancakeHouseMenu.createIterator(); if (isVegetarian(name, pancakeIterator)) { return true; } Iterator dinerIterator = dinerMenu.createIterator(); if (isVegetarian(name, dinerIterator)) { return true; } return false; } private void printVegetarianMenu(Iterator iterator) { while (iterator.hasNext()) { MenuItem menuItem = (MenuItem)iterator.next(); if (menuItem.isVegetarian()) { System.out.print(menuItem.getName()); System.out.println("/t/t" + menuItem.getPrice()); System.out.println("/t" + menuItem.getDescription()); } } } private boolean isVegetarian(String name, Iterator iterator) { while (iterator.hasNext()) { MenuItem menuItem = (MenuItem)iterator.next(); if (menuItem.getName().equals(name)) { if (menuItem.isVegetarian()) { return true; } } } return false; } }

這樣我們通過接口抽象完成了迭代器和菜單的鬆耦合。但需要注意的是，這個線程不安全。當然，有人會問是不是可以實現向後移動，比如pervious(),那麼這時你還必須實現一個方法hasPervious()來驗證是不是已經到頂端。Java中有一個ListIterator可以供參考。

 

5.最後我們思考一個問題：那我們爲什麼不在這兩個聚合（早餐菜單和晚餐菜單）的內部實現迭代器功能的相關方法呢？我們可以分析一下這個問題如果答案是“可以”的話，將會帶來什麼。若這個集合改變的話，我們要修改這個類；若遍歷的方法改變的話，我們要修改這個類——我們至少有兩個引起類變化的原因。這會導致代碼的重構效率大大降低。

由此我們引出一個設計原則：單一原則——一個類應該只有一個引起變化的原因，類的每個職責都有改變的潛在區域，一旦超過職責就意味着超過“一個改變”的區域。這個原則極難遵守，因爲我們的大腦總習慣自然地把很多東西聚在一起。我們經常說“高內聚”，其實真正的含義在於——當一個模塊或一個類被設計爲只支持一組相關的功能時，我們稱其爲高內聚；反之，當被設計爲支持一組不相關的功能時，我們說其低內聚。