設計模式——10 迭代器模式

阿新 • • 發佈：2018-12-20

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());
		}
	}
	
}

最後又到了喜聞樂見的總結部分，我們又來總結我們現在現有的設計模式武器。

面向物件基礎

抽象、封裝、多型、繼承

八大設計原則

設計原則一：封裝變化

設計原則二：針對介面程式設計，不針對實現程式設計。

設計原則三：多用組合，少用繼承。

設計原則四：為互動物件之間的鬆耦合設計而努力

設計原則五：對擴充套件開放，對修改關閉

設計原則六：依賴抽象，不要依賴於具體的類

設計原則七：只和你的密友談話

設計原則八：別找我，我有需要會找你

設計原則九：類應該只有一個改變的理由

模式

迭代器模式：提供一個方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的實現。

最後獻上此次設計所涉及到的原始碼，有需要的小夥伴可以下載來執行一下，首先先自己進行設計，然後再參考，這樣才能加深模式的理解。

設計模式——10 迭代器模式

10 Iterator Pattern（迭代器模式）

面向物件基礎

八大設計原則

模式

設計模式——10 迭代器模式

設計模式的藝術行為型模式之迭代器模式

（五）設計模式之迭代器模式（Iterator）

二十三種設計模式[16] - 迭代器模式(Iterator Pattern)

golang設計模式之迭代器模式

Java進階篇設計模式之九----- 直譯器模式和迭代器模式

【設計模式】迭代器模式

23種設計模式之迭代器模式

設計模式系列- 迭代器模式

Android設計模式之迭代器模式

Python進階：設計模式之迭代器模式

設計模式(一）：Iterator模式（迭代器模式）

設計模式初探-迭代器模式(ITERATOR)又稱遊標(Cursor)

設計模式之迭代器模式（Iterator Pattern）

設計模式之迭代器模式

javascript設計模式之迭代器模式

c++設計模式：迭代器模式(Iterator Pattern)

C++設計模式之迭代器模式

設計模式：迭代器模式（Iterator Pattern）

Java設計模式之迭代器模式（Iterator Pattern）

設計模式——10 迭代器模式

10 Iterator Pattern（迭代器模式）

面向物件基礎

八大設計原則

模式

相關推薦