国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

打開APP
userphoto
未登錄

開通VIP，暢享免費電子書等14項超值服

開通VIP

首頁

好書

留言交流

下載APP

聯(lián)系客服
《Head First設計模式》
1.迭代器（Iterator）模式部分

----Sharpen Your Pencil解答----
A、C、D、E
------------

*當我們說“集合（Collection）”的時候，我們指的是一群對象。其存儲方式可以是各式各樣的數(shù)據(jù)結構，例如：列表、數(shù)組、散列表，無論用什么方式存儲，一律可以視為集合。有時候也被稱為聚合（aggregate）。

Java代碼
  1. ----習題解答----   
  2. public class PancakeHouseIterator implements Iterator {   
  3.     private List items;   
  4.        
  5.     private int position = 0;   
  6.        
  7.     public PancakeHouseIterator(List items) {   
  8.         this.items = items;   
  9.     }   
  10.        
  11.     public Object next() {   
  12.         position += 1;   
  13.         return items.get(position);   
  14.     }   
  15.        
  16.     public boolean hasNext() {   
  17.         if(position >= items.size()){   
  18.             return false;   
  19.         } else {   
  20.             return true;   
  21.         }   
  22.     }   
  23. }   
  24.   
  25. public class PancakeHouseMenu {   
  26.     ArrayList menuItems;   
  27.        
  28.     // 這里是構造器   
  29.        
  30.     // 這里是addItem()方法   
  31.        
  32.     // 刪除此方法   
  33.     //public ArrayList getMenuItems() {   
  34.     //    return menuItems;   
  35.     //}   
  36.        
  37.     // 新增的方法   
  38.     public Iterator createIterator() {   
  39.         return new PancakeHouseIterator(menuItems);   
  40.     }   
  41.        
  42.     // 其他方法   
  43. }   
  44. ------------  


*在實現(xiàn)java.util.Iterator接口時，如果不需要remove()方法，可以跑出java.lang.UnsupportedOperationException異常。

迭代器模式：提供一種順序訪問集合對象中各個元素的方法，而又不暴露其內部的表示（也就是數(shù)據(jù)結構）。

*迭代器（Iterator）模式把元素之間游走的任務交給了迭代器，而不是聚合對象。這不僅讓聚合的接口和實現(xiàn)變得更簡潔，也讓它專注于管理對象，而不必理會遍歷的事情。

----Brain Power解答----
工廠方法（Factory Method）模式
------------

*類的每個責任都有一個潛在的改變區(qū)域，多一個責任就意味著多一個改變的區(qū)域。要盡量讓每個類保持單一責任。

軟件設計原則：一個類應該只有一個引起變化的原因。

*既要讓每個類都保持單一的責任，也要保證一個責任只指派給一個類。

*內聚（Cohesion）用來度量一個類或模塊緊密地達到單一目的或責任的程度。

*當一個類或模塊被設計成只支持一組相關功能時，我們說它具有高內聚；反之，當被設計成支持一組不相關的功能時，我們說它具有低內聚。

----Brain Power解答----
具有多重責任的類：Game、Person、DeckOfCards、ShoppingCart、Iterator
------------

----Brain Power 2解答----
低內聚類：Game
高內聚類：GameSession、PlayerActions、Player
------------

----Sharpen Your Pencil解答---
1、定義一個迭代器類，實現(xiàn)咖啡廳菜單的遍歷
2、刪除CafeMenu類的getItems()方法
3、讓CafeMenu類繼承Menu接口并實現(xiàn)createIterator()方法
------------

*框架（framework）指一群類和接口。

*在Java 5中新增了一種“for/in”語句支持對集合類的遍歷。形式如下：
for(Object obj:collection) {
    obj.methodName();
    ...
}

Java代碼
  1. ----代碼貼解答----   
  2. import java.util.Iterator;   
  3. import java.util.Calendar;   
  4.   
  5. public class AlternatingDinerMenuIterator implements Iterator {   
  6.     MenuItem[] items;   
  7.     int position;   
  8.        
  9.     public AlternatingDinerMenuIterator(MenuItem[] items) {   
  10.         this.items = items;   
  11.         Calendar rightNow = Calendar.getInstance();   
  12.         position = rightNow.get(Calendar.DAY_OF_WEEK) % 2;   
  13.     }   
  14.        
  15.     public boolean hasNext() {   
  16.         if (position >= items.length || items[position] == null) {   
  17.             return false;   
  18.         } else {   
  19.             return true;   
  20.         }   
  21.     }   
  22.        
  23.     public Object next() {   
  24.         MenuItem menuItem = items[position];   
  25.         position = position + 2;   
  26.         return menuItem;   
  27.     }   
  28.        
  29.     public void remove() {   
  30.         throw new UnsupportedOperationException("Alternating Diner Menu Iterator does not support remove()");   
  31.     }   
  32. }   
  33. ------------   
  34.   
  35. ----Brain Power解答----   
  36. 修改女招待類如下：   
  37. public class Waitress {   
  38.     MenuItem[] menus;   
  39.        
  40.     public Waitress(MenuItem[] menus) {   
  41.         this.menus = menus;   
  42.     }   
  43.        
  44.     public void printMenu() {   
  45.         for(MenuItem menu: menus) {   
  46.             printMenu(menu.createIterator());   
  47.         }   
  48.     }   
  49.        
  50.     private void printMenu(Iterator items) {   
  51.         while(items.hasNext()) {   
  52.             MenuItem item = (MenuItem)items.next();   
  53.             ...   
  54.         }   
  55.     }   
  56. }   
  57. ------------  


2.組合（Composite）模式部分

組合模式：將對象組合成樹狀結構來表現(xiàn)“整體/部分”的層級結構，讓客戶以一致的方式來處理個別對象以及對象組合。

*在樹狀結構中，帶有子元素的元素成為節(jié)點（Node）；沒有子元素的元素成為葉節(jié)點（Leaf）。

*組合（Composite）模式犧牲了單一責任設計原則，換取了透明性（Transprency）。

----Brain Power解答----
從上到下，從左到右一次遍歷樹結構的所有節(jié)點。
------------

*空迭代器（Iterator）是空對象（null object）“設計模式”的又一個例子，之前的例子是“空命令（NullCommand）”。

Java代碼
  1. ----空迭代器實例----   
  2. public class NullIterator implements Iterator {   
  3.     public boolean hasNext() {   
  4.         return false;   
  5.     }   
  6.        
  7.     public Object next() {   
  8.         return null;   
  9.     }   
  10.        
  11.     public void remove() {   
  12.         throw new UnsupportedOperationException();   
  13.     }   
  14. }   
  15. ------------  


*“空對象設計模式”帶來的好處是客戶不用處理null，因此不必擔心系統(tǒng)會跑出NullPointerException。

*當多個對象彼此之間有“整體/部分”的關系，并且你想用一致的方式處理這些對象時（就是讓它們看起來一樣，有共同的方法可以調用），就需要用組合（Composite）模式。

*包含其它組件的組件被稱為組合對象，沒有包含其它組件的組件被稱為葉節(jié)點對象。

*組合通常是樹形結構，也就是一種層次結構，根就是頂層的組合，往下是它的孩子，最末端是葉節(jié)點。

*為了更方便操作，比如把一個子節(jié)點從它的父節(jié)點刪除，可以讓子節(jié)點保存到父節(jié)點的一個引用。

*在組合中加入緩存可以提高遍歷的性能。

----連連看解答----
策略->封裝可互換的行為，并用委托決定使用哪一個
適配器->改變一個或多個類的接口
迭代器->提供一個方式來遍歷組合，而無需暴露組合的實現(xiàn)
外觀->簡化一群類的接口
組合->客戶可以將對象的組合以及個別對象一視同仁
觀察者->當某個狀態(tài)改變時，允許一群對象能被通知到
------------

3.迭代器（Iterator）模式與組合（Compsite）模式小結

*迭代器允許訪問聚合的元素，而不需要暴露它內部的結構。

*迭代器將遍歷聚合的工作封裝進一個對象里。

*當使用迭代器時，我們依賴聚合提供遍歷。

*迭代器提供了一個通用的接口，讓我們遍歷聚合的項，當我們編碼使用聚合的項時，就可以使用多態(tài)機制。

*我們應該努力讓一個類只分配一個責任。

*組合模式提供一個結構，可同時包容個別對象和組合對象。

*組合對象允許客戶對個別對象和組合對象一視同仁。

*組合結構內的任意對象稱為組件，組件可以是組合，也可以是葉節(jié)點。

*在實現(xiàn)組合模式時，有許多設計上的折中；要根據(jù)需要平衡透明性和安全性。

4.迭代器（Iterator）模式實例

Java代碼
  1. //迭代器接口   
  2. public interface Iterator {   
  3.     public boolean hasNext();   
  4.   
  5.     public Object next();   
  6. }   
  7.   
  8. //數(shù)組迭代器   
  9. public class ArrayIterator implements Iterator {   
  10.     private Object[] objects;   
  11.   
  12.     private int position = 0;// 當前位置   
  13.   
  14.     public ArrayIterator(Object[] objects) {   
  15.         this.objects = objects;   
  16.     }   
  17.   
  18.     public boolean hasNext() {   
  19.         return position < objects.length - 1;   
  20.     }   
  21.   
  22.     public Object next() {   
  23.         Object retObj = objects[position];   
  24.         position += 1;   
  25.         return retObj;   
  26.     }   
  27. }   
  28.   
  29. // List迭代器   
  30. public class ListIterator implements Iterator {   
  31.     private java.util.Iterator iter;   
  32.   
  33.     public ListIterator(List list) {   
  34.         this.iter = list.iterator();   
  35.     }   
  36.   
  37.     public boolean hasNext() {   
  38.         return iter.hasNext();   
  39.     }   
  40.   
  41.     public Object next() {   
  42.         return iter.next();   
  43.     }   
  44. }  


5.組合（Composite）模式實例

基于以上代碼實現(xiàn)：
Java代碼
  1. // 菜單接口   
  2. public interface IMenu {   
  3.     // 取得名稱   
  4.     public String getName();   
  5.   
  6.     // 顯示   
  7.     public void display();   
  8.   
  9.     // 添加菜單   
  10.     public void addItem(IMenu menu);   
  11.   
  12.     // 取得所有子菜單   
  13.     public Iterator getChildren();   
  14. }   
  15.   
  16. // 菜單   
  17. public class Menu implements IMenu {   
  18.     private List<IMenu> items = new ArrayList<IMenu>();   
  19.   
  20.     private String name;   
  21.   
  22.     public Menu(String name) {   
  23.         this.name = name;   
  24.     }   
  25.   
  26.     public void addItem(IMenu menu) {   
  27.         items.add(menu);   
  28.     }   
  29.   
  30.     public void display() {   
  31.         System.out.println(this.name + ":Menu");   
  32.         Iterator children = this.getChildren();   
  33.         while (children.hasNext()) {   
  34.             IMenu menu = (IMenu) children.next();   
  35.             menu.display();   
  36.         }   
  37.     }   
  38.   
  39.     public Iterator getChildren() {   
  40.         return new ListIterator(items);   
  41.     }   
  42.   
  43.     public String getName() {   
  44.         return this.name;   
  45.     }   
  46. }   
  47.   
  48. // 菜單項   
  49. public class MenuItem implements IMenu {   
  50.     private String name;   
  51.   
  52.     public MenuItem(String name) {   
  53.         this.name = name;   
  54.     }   
  55.   
  56.     public void display() {   
  57.         System.out.println(this.name + ":MenuItem");   
  58.     }   
  59.   
  60.     public String getName() {   
  61.         return this.name;   
  62.     }   
  63.   
  64.     public void addItem(IMenu menu) {   
  65.         throw new UnsupportedOperationException();   
  66.     }   
  67.   
  68.     public Iterator getChildren() {   
  69.         return new NullIterator();   
  70.     }   
  71. }   
  72.   
  73. // 菜單條   
  74. public class MenuBar {   
  75.     private List<IMenu> menus = new ArrayList<IMenu>();   
  76.   
  77.     public void addMenu(IMenu menu) {   
  78.         this.menus.add(menu);   
  79.     }   
  80.   
  81.     public void display() {   
  82.         System.out.println(":MenuBar");   
  83.         Iterator items = new ListIterator(menus);   
  84.         while (items.hasNext()) {   
  85.             IMenu menu = (IMenu) items.next();   
  86.             menu.display();   
  87.         }   
  88.     }   
  89. }   
  90.   
  91. // 空迭代器   
  92. public class NullIterator implements Iterator {   
  93.     public boolean hasNext() {   
  94.         return false;   
  95.     }   
  96.   
  97.     public Object next() {   
  98.         return null;   
  99.     }   
  100. }   
  101.   
  102. // 測試程序   
  103. public class TestMenuBar {   
  104.     public static void main(String[] args) {   
  105.         IMenu menu1 = new Menu("File");   
  106.         IMenu item1 = new MenuItem("  New");   
  107.         IMenu item2 = new MenuItem("  Open");   
  108.         IMenu item3 = new MenuItem("  Exit");   
  109.         menu1.addItem(item1);   
  110.         menu1.addItem(item2);   
  111.         menu1.addItem(item3);   
  112.   
  113.         IMenu menu2 = new Menu("Edit");   
  114.         IMenu item4 = new MenuItem("  Cut");   
  115.         IMenu menu3 = new Menu("  Find");   
  116.         IMenu item5 = new MenuItem("    Find Next");   
  117.         IMenu item6 = new MenuItem("    Find Previous");   
  118.         IMenu item7 = new MenuItem("    Replace");   
  119.         IMenu item8 = new MenuItem("  Copy");   
  120.         menu2.addItem(item4);   
  121.         menu2.addItem(menu3);   
  122.         menu2.addItem(item8);   
  123.         menu3.addItem(item5);   
  124.         menu3.addItem(item6);   
  125.         menu3.addItem(item7);   
  126.   
  127.         MenuBar bar = new MenuBar();   
  128.         bar.addMenu(menu1);   
  129.         bar.addMenu(menu2);   
  130.         bar.display();   
  131.     }   
  132. }  


測試結果：
引用
:MenuBar
File:Menu
  New:MenuItem
  Open:MenuItem
  Exit:MenuItem
Edit:Menu
  Cut:MenuItem
  Find:Menu
    Find Next:MenuItem
    Find Previous:MenuItem
    Replace:MenuItem
  Copy:MenuItem


--END--
本站僅提供存儲服務，所有內容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權內容，請點擊舉報。
打開APP，閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
JAVA設計模式之迭代器設計模式
迭代器模式的理解和示例
設計模式之迭代器與組合模式（二）
iterator component
Android ActionBar 使用詳解
設計模式讀書筆記-----迭代器模式
更多類似文章 >>
生活服務
分享 收藏 導長圖 關注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權！
如果VIP功能使用有故障，
可點擊這里聯(lián)系客服！

聯(lián)系客服