10 Iterator Pattern（迭代器模式）

前言：幫助客戶用同樣的方法遍歷不同的集合。
需求：
由于海岸城的店租極具增長，Vander的Pizza店和燒烤店需要合并在一起了，合并在一起，這兩家店的主廚A和主廚B，他們的菜單實現(xiàn)卻不相同，Pizza店的菜單是使用List，而燒烤店的菜單用的卻是數(shù)組，讓我們先來看看他們菜單的實現(xiàn)。
首先兩個主廚都是使用了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結(jié)構(gòu)來存放菜單項目的，而BarbecueMenu則是用數(shù)組來存放菜單項目的。Vander作為老板又是他大顯神威的時候了，他需要做一個菜單綜合顯示平臺，顯示出PizzaMenu和BarbecueMenu。我們來看看Vander的實現(xiàn)：

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++) {//數(shù)組的大小為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());
        }

    }

}

實現(xiàn)效果：

image.png

Vander這么設(shè)計真的好嗎？
1、MenuAdmin是不是直接針對PizzaMenu跟BarbecueMenu進行編碼的，而不是針對接口編程。
2、如果又加入了日式料理菜單，而菜單是用HashMap實現(xiàn)的，豈不是又得需要修改很多MenuAdmin的代碼。
3、MenuAdmin直接關(guān)心了PizzaMenu和BarbecueMenu的內(nèi)部實現(xiàn)了，違反了封裝原則。
4、displayMenu部分有重復(fù)代碼，有兩個類似的循環(huán)，如果加入第三個菜單又需要多一個循環(huán)。
Panda大師一看，又是糟糕的設(shè)計，Vander你就不能找一個迭代器來遍歷這些數(shù)據(jù)嗎，不同的數(shù)據(jù)結(jié)構(gòu)實現(xiàn)不同的迭代器，MenuAdmin只需要用同樣的循環(huán)就可以遍歷這些菜單項了。接著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());
        }
    }
    
}

下面是迭代器實現(xiàn)的基礎(chǔ)類圖：

這里可能會有幾個問題：
1、能不能直接用BarbecueMenu直接實現(xiàn)迭代器接口？
答案是可以的，但是代碼侵入性太大，我們要保證原有類不進行太大的變動，再說了廚師們也不喜歡你亂搞。
2、MenuAdmin中的兩個屬性能不能直接是兩個菜單對應(yīng)的迭代器？
答案也是可以的，但是這樣雖然實現(xiàn)上沒有問題，但是迭代器作為較為低層的部分，這么做在邏輯上說不過去，本來菜單管理的類里面就應(yīng)該是菜單管理的，突然屬性變成了迭代器，這就有點奇怪了。

分析：
實際上當(dāng)前的MenuAdmin依然是針對實現(xiàn)編程的，PizzaMenu和BarbecueMenu都有createIterator方法，所以可以定義一個Menu接口，java.util中的ArrayList實際上已經(jīng)幫我們實現(xiàn)了Iterator了，我們直接用就可以了。接下來，進行下一步改造。
我們首先刪除我們自己定義的Iterator接口和PizzaMenuIterator（由于ArrayList本身就有迭代器實現(xiàn)），然后import進java.util.Iterator接口，然后將MenuAdmin中的實現(xiàn)改成接口，改寫PizzaMenu類中的createIterator方法就完成了。
Menu：

public interface Menu<T> {

    /**
     * 創(chuàng)建迭代器
     * @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不再針對于實現(xiàn)編程，而是針對接口（Menu）編程，減少了其對具體類的依賴。
2、每個菜單都要求要實現(xiàn)Menu接口，所以每個菜單必須提供createIterator方法，讓菜單管理類能夠獲得Iterator。MenuAdmin類也不需要關(guān)心每個菜單內(nèi)部用了什么結(jié)構(gòu)去存儲數(shù)據(jù)，只需要用迭代器的方法就能完成遍歷。

下面我們隆重有請迭代器模式登場：

迭代器模式：提供一種方法順序訪問一個聚合對象中的各個元素，而又不暴露其內(nèi)部的實現(xiàn)。迭代器模式把元素之間的游走的責(zé)任交給迭代器，而不是聚合對象，這不僅讓聚合的接口和實現(xiàn)變得更簡潔，也可以讓聚合更專注在它所應(yīng)該專注的事情（也就是管理對象集合），而不必去理會遍歷的事情。

迭代器的套路如下圖所示，這里的Client對應(yīng)MenuAdmin，ConcreteInterator對應(yīng)PizzaMenuIterator和BarbecueMenuIterator，Aggregate對應(yīng)Menu接口，ConcreteAggregate對應(yīng)PizzaMenu和BarbecueMenu。

迭代器一般類圖

這里簡單說明一下聚合對象，首先當(dāng)我們說集合的時候，是指一群對象，其存儲方式可以是各種各樣的數(shù)據(jù)結(jié)構(gòu)，例如列表、數(shù)組、散列表，有時候集合也會叫做聚合。

還記得我們剛剛討論的嗎，為什么不直接用PizzaMenu來實現(xiàn)Iterator接口然后實現(xiàn)遍歷集合的這些方法？
當(dāng)你這么做之后，就會發(fā)現(xiàn)PizzaMenu不僅僅要維護MenuItems這個集合，還要承擔(dān)遍歷這個集合的責(zé)任，這樣的話，這個集合改變，MenuItem就必須改變，若遍歷的方式改變，這個集合又要改變，這樣它就承擔(dān)了兩種變化的風(fēng)險了。根據(jù)這個理念，我們引入了單一變化原則來說明這件事情。
單一變化原則： $\color{blue}{一個類應(yīng)該只有一個引起變化的原因。}$
類的每一個責(zé)任都有改變的潛在區(qū)域。超過一個責(zé)任，意味著超過一個改變的區(qū)域。這個原則告訴我們盡量讓每個類保持“單一責(zé)任”。
$\color{blue}{高內(nèi)聚低耦合}$ 是我們經(jīng)常聽到的， $\color{blue}{內(nèi)聚}$ 是用來度量一個類或一個模塊緊密地達到單一目的或責(zé)任。當(dāng)一個類或模塊被設(shè)計成只支持一組相關(guān)地功能時，我們說它具有高內(nèi)聚；反之，當(dāng)被設(shè)計成支持一組不相關(guān)地功能時，我們說它具有低內(nèi)聚。內(nèi)聚是一個比單一責(zé)任更加普遍的概念，但兩者關(guān)系密切，遵守這原則的類容易具有很高的凝聚力，比低內(nèi)聚的類容易維護得多。

Vander在歡樂海岸的火鍋店的店租也越來越貴了，近兩個月甚至已經(jīng)入不敷出了，所以它決定擴大pizza店的店面，加入燒烤之后再加入火鍋，這樣讓客人有更多地選擇，可惜地是廚師C的自助火鍋店的菜單又是用另一種數(shù)據(jù)結(jié)構(gòu)來完成的，不要緊，現(xiàn)在采用的系統(tǒng)已經(jīng)具有一定的擴展性了。接下來添加火鍋店的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());
        }
    }
    
}

最后又到了喜聞樂見的總結(jié)部分，我們又來總結(jié)我們現(xiàn)在現(xiàn)有的設(shè)計模式武器。

面向?qū)ο蠡A(chǔ)

抽象、封裝、多態(tài)、繼承

九大設(shè)計原則

設(shè)計原則一：封裝變化
設(shè)計原則二：針對接口編程，不針對實現(xiàn)編程
設(shè)計原則三：多用組合，少用繼承
設(shè)計原則四：為交互對象之間的松耦合設(shè)計而努力
設(shè)計原則五：對擴展開放，對修改關(guān)閉
設(shè)計原則六：依賴抽象，不要依賴于具體的類
設(shè)計原則七：只和你的密友談話
設(shè)計原則八：別找我，我有需要會找你
設(shè)計原則九：類應(yīng)該只有一個改變的理由

模式

迭代器模式：提供一個方法順序訪問一個聚合對象中的各個元素，而又不暴露其內(nèi)部的實現(xiàn)。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

設(shè)計模式系列教程—Iterator?Pattern（迭代器模式）

設(shè)計模式系列教程—Iterator?Pattern（迭代器模式）

10 Iterator Pattern（迭代器模式）

Iterator（迭代器）接口：

面向?qū)ο蠡A(chǔ)

九大設(shè)計原則

模式

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

設(shè)計模式系列教程—Iterator?Pattern（迭代器模式）

10 Iterator Pattern（迭代器模式）

Iterator（迭代器）接口：

面向?qū)ο蠡A(chǔ)

九大設(shè)計原則

模式

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av