Head First設計模式讀書筆記八第九章下組合模式

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

組合模式+迭代器模式

接著上一節最後的例子，例子的最終list結構圖是這樣的：這裡寫圖片描述若要給DinerMenu新加一種Menu（即下面這樣），則需要對現有結構進行較大改動。

這裡寫圖片描述可以看到，目前的結構中分為兩種結構，一種是menu，是一種容器，可以包含選單項，而第二種是menuItem，是一個節點，只包含該選單項的相關資訊。如果把這種關係推廣到樹形結構，那麼menu則相當於非葉子節點，而menu則相當於葉子節點。從上圖也很容易看出來。運用組合模式，則可以實現上面的這種樹形結構，並且方便我們的遍歷。

組合模式示例

示例基於上一節最後的程式碼改進以MenuComponent為基類

public abstract class MenuComponent {
	//適用於選單項+選單容器
	public String getName() {
		throw new UnsupportedOperationException();
	}
	//適用於選單項+選單容器
	public String getDescription() {
		throw new UnsupportedOperationException();
	}
	//適用於選單項
	public boolean isVegetarian() {
		throw new UnsupportedOperationException();
	}
	//適用於選單項
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	//適用於選單容器
	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	//適用於選單容器
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	//適用於選單容器
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
	//適用於選單容器+選單項
	public void print() {
		throw new UnsupportedOperationException();
	}
}

menu和menuItem繼承之

public class Menu extends MenuComponent {
	String name;
	String description;
	ArrayList<MenuComponent> menuItems;

	public Menu(String name, String description) {
		menuItems = new ArrayList<MenuComponent>();
		this.name = name;
		this.description = description;
	}

	@Override
	public void add(MenuComponent menuComponent) {
		menuItems.add(menuComponent);
	}

	@Override
	public void remove(MenuComponent menuComponent) {
		menuItems.remove(menuComponent);
	}

	@Override
	public MenuComponent getChild(int i) {
		return menuItems.get(i);
	}

	@Override
	public String getName() {
		return this.name;
	}

	@Override
	public String getDescription() {
		return this.description;
	}

	@Override
	public void print() {
		System.out.println(" " + getName());
		System.out.println(" "  + getDescription());
		System.out.println(" ------------------------------------ ");
		Iterator<MenuComponent> iterator = menuItems.iterator();
		//重點 遞迴呼叫
		while (iterator.hasNext()) {
			MenuComponent menuComponent = iterator.next();
			menuComponent.print();
		}
	}

}

關鍵在於這裡的遞迴，利用iterator 遍歷Menu中的子項，注意這些子項既可能是Menu也可能時MenuItem。如果時MenuItem，則呼叫的是MenuItem的print方法，如果是Menu，則會呼叫Menu的print，此時則會進入選單的第一次遞迴呼叫。這裡其實運用到多型的思想。

public class MenuItem extends MenuComponent {
	String name;
	String description;
	boolean vegetarian;
	double price;

	public MenuItem(String name, String description, boolean vegetarian,
			double price) {
		super();
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getDescription() {
		return description;
	}

	@Override
	public boolean isVegetarian() {
		return vegetarian;
	}

	@Override
	public double getPrice() {
		return price;
	}

	@Override
	public void print() {
		System.out.println(" " + getName());
		System.out.println("isVegetarian " + isVegetarian());

		System.out.println(" " + getPrice());
		System.out.println(" --" + getDescription());
	}

	@Override
	public String toString() {
		return "name =" + name + " description " + description
				+ " isVegetarian " + vegetarian + " price= " + price;
	}
}

改進Waitress

public class Waitress {
	MenuComponent allMenus;

	public Waitress(MenuComponent allMenus) {
		this.allMenus = allMenus;
	}

	public void printMenu() {
		allMenus.print();
	}
}

DinerMenu和PancakeHouseMenu沒有存在必要了，改寫測試類

public class Printer2 {

	public static void main(String[] args) {
		MenuComponent breakfasetMenu = new Menu("PANCAKE HOUSE MENU", "breakfast");
		MenuComponent lunchMenu = new Menu("LUNCH MENU", "lunch");
		MenuComponent dinerMenu = new Menu("DINER MENU", "diner");
		
		MenuComponent allMenuComponent = new Menu("ALL MENUS","All menus combined");
		allMenuComponent.add(dinerMenu);
		allMenuComponent.add(lunchMenu);
		allMenuComponent.add(breakfasetMenu);
		dinerMenu.add(new MenuItem("diner menu item1", "dinermenu item1", true, 1.23));
		dinerMenu.add(new MenuItem("diner menu item2", "dinermenu item2", false, 1.43));
		dinerMenu.add(new MenuItem("diner menu item3", "dinermenu item3", true, 3.23));
		lunchMenu.add(new MenuItem("lunchMenu menu item1", "lunchMenu item1", false, 1.434));
		lunchMenu.add(new MenuItem("lunchMenu menu item2", "lunchMenu item2", true, 6.5));
		breakfasetMenu.add(new MenuItem("breakfasetMenu menu item1", "breakfasetMenu item1", true, 1.2));
		breakfasetMenu.add(new MenuItem("breakfasetMenu menu item2", "breakfasetMenu item2", false, 1.12));
		
		Waitress waitress = new Waitress(allMenuComponent);
		waitress.printMenu();
		
	}

}

測試結果：

 ALL MENUS
 All menus combined
 ------------------------------------ 
 DINER MENU
 diner
 ------------------------------------ 
 diner menu item1
isVegetarian true
 1.23
 --dinermenu item1
 diner menu item2
isVegetarian false
 1.43
 --dinermenu item2
 diner menu item3
isVegetarian true
 3.23
 --dinermenu item3
 LUNCH MENU
 lunch
 ------------------------------------ 
 lunchMenu menu item1
isVegetarian false
 1.434
 --lunchMenu item1
 lunchMenu menu item2
isVegetarian true
 6.5
 --lunchMenu item2
 PANCAKE HOUSE MENU
 breakfast
 ------------------------------------ 
 breakfasetMenu menu item1
isVegetarian true
 1.2
 --breakfasetMenu item1
 breakfasetMenu menu item2
isVegetarian false
 1.12
 --breakfasetMenu item2

完成時的類結構：可以看到，在組合模式中，Menu和MenuItem都是一個個節點，都可以參與遍歷。注意：Waitess其實一個Menu節點，為了與上面的例子結合起來看，我將他寫成了Waitress，其實重點應該在Waitress中包含的allMenus例項。組合模式的思想

關鍵點：繼承同一個抽象類。 可以看到Menu和MenuItem都繼承了抽象父類MenuComponent，這樣做可以忽略容器和葉子節點的節點的區別。至於為什麼這麼做，是方便選單項和子項的統一遍歷（不需要區分是Menu還是MenuItem----多型的功勞）試想一下，如果只有Menu的話，遍歷順序是什麼樣的呢？從上面的輸出結果，不難想象，這種遍歷，與二叉樹的先序遍歷極為類似。至於MenuItem則可以想象為不能擁有子節點的Menu。以上總結為兩點：１.組合模式如何實現：容器（MENU）與節點（MENUITEM）繼承同一個介面２.組合模式目的：實現更簡潔的遍歷

等一下，MenuComponent似乎違背了單一職責原則？ 通常，我們推薦一個類只幹一件事，但是在MenuComponent似乎既幹了選單的事情也幹了選單項的事情，如何解釋呢？沒錯，組合模式的確違反了單一職責原則，但是這是有目的的。組合模式通過這種方式讓容器節點和葉子節點一視同仁的遍歷和操作，使用者不需要知道他操作的是容器節點還是葉子節點。如果我們不採用這種方式，那麼客戶勢必需要使用instanceof來判斷、分別處理葉子和容器節點，這樣透明性變差（使用者需要知道節點的內部結構）。因此這裡的操作是犧牲單一職責換取透明性（使用者不需要知道他操作的是容器節點還是葉子節點）。在日常開發中，類似的權衡處理方式是時間換空間或者空間換時間的演算法，這樣應該更容易理解吧？

組合模式終極版：組合（外部）迭代器

1.改進MenuComponent，新增新方法

	//新增方法 適用於選單+選單項
	public Iterator<MenuComponent> createIterator(){
		throw new UnsupportedOperationException();
	}

２.為Menu和MenuItem各自實現該方法 Menu：

	@Override
	public Iterator<MenuComponent> createIterator() {
		return menuItems.iterator();
	}

MenuItem：

	@Override
	public Iterator<MenuComponent> createIterator() {
		return new NullIterator();
	}

３.NullIterator：（空迭代器）

public class NullIterator implements Iterator<MenuComponent> {

	public boolean hasNext() {
		return false;
	}

	public MenuComponent next() {
		return null;
	}

}

４.組合迭代器登場

public class CompositeIterator implements Iterator<MenuComponent> {

	Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();//儲存iterator的棧

	public CompositeIterator(Iterator<MenuComponent> iterator) {
		stack.push(iterator);
	}

	public boolean hasNext() {
		if (stack.isEmpty()) {
			// if stack is null, does not have next
			return false;
		} else {
			// get the top of stack
			Iterator<MenuComponent> iterator = stack.peek();
			if (!iterator.hasNext()) {
				//如果棧頂iterator沒有元素 彈出該iterator，遞迴判斷是否hasNext
				if(iterator instanceof CompositeIterator){
					System.out.println("pop>>>>>>>>>>>>>>>>>>>"+((CompositeIterator)stack.pop()));
				}else{
					System.out.println("pop>>>>>>>>>>>>>>>>>>>"+iterator.getClass());
					stack.pop();
				}
				
				return hasNext();
			} else {
				//棧頂iterator有next元素，返回true
				return true;
			}
		}
	}

	public MenuComponent next() {
		System.out.println("xxxxx");
			//取出棧頂iterator
			Iterator<MenuComponent> iterator = stack.peek();
			//取出棧頂iterator的next
			MenuComponent menuComponent = iterator.next();
			System.out.println("hasNEx");
			if (menuComponent instanceof Menu) {
				//如果是Menu型別 還需要放入棧內 為了後面的遍歷
				System.out.println("<<<<<<<<<<<<<<<<<<<<<push"+menuComponent.getName()+" "+stack.push(menuComponent.createIterator()));
			}
			//不管是Menu還是MenuItem都返回
			return menuComponent;
	}

}

5.當然侍者類也要改進

public class Waitress {
	MenuComponent allMenus;

	public Waitress(MenuComponent allMenus) {
		this.allMenus = allMenus;
	}

	public void printMenu() {
		allMenus.print();
	}
	public void printVegetarianMenu(){
		//得到allMenu的Iterator 其型別為CompositeIterator（所有Menu的createIterator返回的實際例項型別為CompositeIterator）
		//遍歷之得到 儲存在 allMenus的MenuComponent
		Iterator<MenuComponent> iterator = allMenus.createIterator();
		System.out.println(" printVegetarianMenu  ");
		while(iterator.hasNext()){//呼叫的CompositeIterator的hasNext
			MenuComponent menuComponent =iterator.next();
			System.out.println("for next....");
			try{
				if(menuComponent.isVegetarian()){
					menuComponent.print();
				}
			}catch(UnsupportedOperationException e){
				System.err.println("Not a menuItem");
			}
		}
	}
}
/**
遍歷過程：
1.對allMenus遍歷 將breakfasetMenu和lunchMenu放入stack                              
2.對breakfasetMenu進行遍歷，判斷其子元素是否是蔬菜，遍歷完畢，從stack彈出breakfasetMenu
3.對lunchMenu進行遍歷，判斷子元素是否是蔬菜，遇到dinerMenu時放入stack                        
4.對dinerMenu進行遍歷，判斷子元素是否是蔬菜，遍歷完畢，彈出dinerMenu
5.對lunchMenu遍歷完畢，彈出lunchMenu.
6.對allMenus遍歷完畢，彈出allMenus，遍歷終了
 */

遍歷圖：在這裡插入圖片描述不過dinner貌似會被push兩次，所以會輸出兩次。看來幾遍沒找到原因。。以後再看看吧。。 log：

 printVegetarianMenu  
Not a menuItem
<<<<<<<<<<<<<<<<<<<<<pushPANCAKE HOUSE MENU [email protected]
for next....
for next....
 ====================
 breakfasetMenu menu item1
isVegetarian true
 1.2
 breakfasetMenu item1
 ====================
for next....
pop>>>>>>>>>>>>>>>>>>>class java.util.ArrayList$Itr
pop>>>>>>>>>>>>>>>>>>>[email protected]
<<<<<<<<<<<<<<<<<<<<<pushLUNCH MENU [email protected]
for next....
Not a menuItem
for next....
<<<<<<<<<<<<<<<<<<<<<pushDINER MENU [email protected]
<<<<<<<<<<<<<<<<<<<<<pushDINER MENU [email protected]
for next....
Not a menuItem
for next....
 ====================
 diner menu item1
isVegetarian true
 1.23
 dinermenu item1
 ====================
for next....
for next....
 ====================
 diner menu item3
isVegetarian true
 3.23
 dinermenu item3
 ====================
pop>>>>>>>>>>>>>>>>>>>class java.util.ArrayList$Itr
pop>>>>>>>>>>>>>>>>>>>[email protected]
for next....
 ====================
 diner menu item1
isVegetarian true
 1.23
 dinermenu item1
 ====================
for next....
for next....
 ====================
 diner menu item3
isVegetarian true
 3.23
 dinermenu item3
 ====================
pop>>>>>>>>>>>>>>>>>>>class java.util.ArrayList$Itr
pop>>>>>>>>>>>>>>>>>>>[email protected]
for next....
 ====================
 lunchMenu menu item2
isVegetarian true
 6.5
 lunchMenu item2
 ====================
pop>>>>>>>>>>>>>>>>>>>class java.util.ArrayList$Itr
pop>>>>>>>>>>>>>>>>>>>[email protected]
pop>>>>>>>>>>>>>>>>>>>class java.util.ArrayList$Itr

這個最後的迭代器稍顯複雜，其目的是為了構建一個外部迭代器，但是個人覺得上一個內部迭代器完全夠用了，畢竟對於大多數集合類，有已經支援增強for迴圈了，這個可用可以不用Iterator似乎沒那麼大作用了。至於這個push兩次的問題，有時間再看看吧。。。

Head First設計模式讀書筆記八第九章下組合模式

組合模式+迭代器模式

組合模式示例

組合模式終極版：組合（外部）迭代器

Head First設計模式讀書筆記八第九章下組合模式

深入理解JVM虛擬機器讀書筆記【第九章】類載入及執行子系統的案例與實戰

模式識別學習筆記：第九章非監督模式識別

《Head First Java》讀書筆記

Java編程思想讀書筆記_第三章

Java編程思想讀書筆記_第6章（訪問權限）

Java編程思想讀書筆記_第8章

Java 並發編程實踐基礎讀書筆記：第三章使用 JDK 並發包構建程序

深入理解JVM虛擬機器讀書筆記【第十章】早期(編譯期)優化

深入理解JVM虛擬機器讀書筆記【第七章】虛擬機器類載入機制

機器學習實戰---讀書筆記：第10章利用K均值聚類演算法對未標註資料分組---1

linux核心程式設計讀書筆記【第三章程序管理】

HTTP圖解讀書筆記（第六章 HTTP首部）為cookie服務的首部欄位和其它首部欄位

HTTP圖解讀書筆記（第六章 HTTP首部）實體首部欄位

HTTP圖解讀書筆記（第六章 HTTP首部）響應首部欄位

HTTP圖解讀書筆記（第六章 HTTP首部）請求首部欄位

HTTP圖解讀書筆記（第六章 HTTP首部）通用首部欄位

HTTP圖解讀書筆記（第六章 HTTP首部）首部欄位

HTTP圖解讀書筆記（第五章與HTTP協作的web伺服器）

HTTP圖解讀書筆記（第四章返回結果的HTTP狀態碼）

Head First設計模式讀書筆記八 第九章下 組合模式

組合模式+迭代器模式

組合模式示例

組合模式終極版：組合（外部）迭代器

相關推薦

Head First設計模式讀書筆記八第九章下組合模式