Java 设计模式(10) —— 迭代器模式

一、迭代器模式

提供一种方法顺序访问一个聚合对象中的各个对象

迭代器模式

二、示例

餐馆合并菜单：有一个中餐厅和一个西餐厅合并了，因此服务员服务的时候需要对菜单进行合并，可是

• 1.西餐厅的菜单是用数组实现的
• 2.中餐厅的菜单使用ArrayList实现的

用传统的面向对象的模式方式实现菜单的组合：

1.定义菜单对象

/**
 * 菜单对象
 */
public class MenuItem {
    private String name,description;
    private boolean vegetable;
    private float price;
    public MenuItem(String name,String description,boolean vegetable,float price)
    {
        this.name=name;
        this.description=description;
        this.vegetable=vegetable;
        this.price=price;
        
    }
    public String getName()
    {
        return name;
    }
    public String getDescription()
    {
        return description;
    }
    public float getPrice()
    {
        return price;
    }
    public boolean  isVegetable()
    {
        return vegetable;
    }
}

2.定义西餐厅的菜单

/**
 * 面向对象模式，西餐厅对象，直接返回整个菜单的集合list
 */
public class CakeHouseMenu {
    private ArrayList<MenuItem> menuItems;

    public CakeHouseMenu() {
        menuItems = new ArrayList<MenuItem>();
        
        addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
        addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
        addItem("Stawberry Cake","fresh stawberry",true,3.29f);
        addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
    }

    private void addItem(String name, String description, boolean vegetable,
            float price) {
        MenuItem menuItem = new MenuItem(name, description, vegetable, price);
        menuItems.add(menuItem);
    }
    public ArrayList<MenuItem> getMenuItems() {
        return menuItems;
    }
    
    //其他功能代码
}

3.定义中餐厅的菜单

/**
 * 面向对象模式，中餐厅对象，直接返回菜单的数组对象
 */
public class DinerMenu {
    private final static int Max_Items=5;
    public int numberOfItems=0;
    private MenuItem[] menuItems;
    
    public DinerMenu()
    {
        menuItems=new MenuItem[Max_Items] ;
        addItem("vegetable Blt","bacon&lettuce&tomato&cabbage",true,3.58f);
        addItem("Blt","bacon&lettuce&tomato",false,3.00f);
        addItem("bean soup","bean&potato salad",true,3.28f);
        addItem("hotdog","onions&cheese&bread",false,3.05f);
        
        
    }
    private void addItem(String name, String description, boolean vegetable,
            float price) {
        MenuItem menuItem = new MenuItem(name, description, vegetable, price);
        if(numberOfItems>=Max_Items)
        {
            System.err.println("sorry,menu is full!can not add another item");
        }else{
            menuItems[numberOfItems]=menuItem;
            numberOfItems++;
        }
        
    }
    
    public MenuItem[] getMenuItems() {
        return menuItems;
    }
}

4.服务员输出所有菜单

/**
 * 面向对象模式，服务员对象，负责提供菜单
 */
public class Waitress {
    private CakeHouseMenu mCakeHouseMenu;
    private DinerMenu mDinerMenu;
    private ArrayList<MenuItem> cakeitems;
    private MenuItem[] dineritems;


    public Waitress() {
        mCakeHouseMenu = new CakeHouseMenu();
        cakeitems = mCakeHouseMenu.getMenuItems();

        mDinerMenu = new DinerMenu();
        dineritems = mDinerMenu.getMenuItems();
    }

    /**
     * 传统模式，遍历两个菜单的循环，输出所有的菜单对象
     */
    public void printMenu() {
        MenuItem menuItem;
        for (int i = 0, len = cakeitems.size(); i < len; i++) {
            menuItem = cakeitems.get(i);
            System.out.println(menuItem.getName() + "***"
                    + menuItem.getPrice() + "***" + menuItem.getDescription());

        }
        for (int i = 0, len = mDinerMenu.numberOfItems; i < len; i++) {
            menuItem = dineritems[i];
            System.out.println(menuItem.getName() + "***"
                    + menuItem.getPrice() + "***" + menuItem.getDescription());

        }

    }
}

缺点：直接将集合数据暴露在外面使用，安全性较差；对象与对象之间的耦合度较高；并且不利于拓展新的类型。

三、迭代器模式

自定义一个迭代器接口，每个集合对象实现迭代方法，获取集合数据时则统一操作迭代器即可

1.定义迭代器接口

/**
 * 自定义迭代器接口
 */
public interface Iterator {
    
    public boolean hasNext();
    public Object next();
    

}

2.中西餐厅分别实现迭代方法

    /**
     * 自定义迭代器对象，西餐厅实现迭代方法
     */
    class CakeHouseIterator implements Iterator {
        private int position = 0;

        public CakeHouseIterator() {
            position = 0;
        }

        @Override
        public boolean hasNext() {
            if (position < menuItems.size()) {
                return true;
            }

            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems.get(position);
            position++;
            return menuItem;
        }
    }

    /**
     * 自定义迭代器对象，实现遍历数组的方法
     */
    class DinerIterator implements Iterator {
        private int position;

        public DinerIterator() {
            position = 0;
        }

        @Override
        public boolean hasNext() {
            if (position < numberOfItems) {
                return true;
            }

            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems[position];
            position++;
            return menuItem;
        }
    }

3.输出时只需遍历迭代器即可

/**
 * 迭代器模式，服务员对象
 */
public class Waitress {
    private ArrayList<Iterator> iterators = new ArrayList<Iterator>();


    public Waitress() {

    }

    public void addIterator(Iterator iterator) {
        iterators.add(iterator);
    }

    /**
     * 只需要遍历迭代器即可遍历添加进来的集合数据
     */
    public void printMenu() {
        Iterator iterator;
        MenuItem menuItem;
        for (int i = 0, len = iterators.size(); i < len; i++) {
            iterator = iterators.get(i);

            while (iterator.hasNext()) {
                menuItem = (MenuItem) iterator.next();
                System.out.println(menuItem.getName() + "***"
                        + menuItem.getPrice() + "***" + menuItem.getDescription());

            }
        }
    }
}

/**
 * 迭代器模式，自定义迭代器接口
 * 实现迭代器的遍历方法后即可将不同类型的集合数据统一遍历输出
 */
public class MainTest {
    public static void main(String[] args) {
        Waitress mWaitress=new Waitress();
        CakeHouseMenu mCakeHouseMenu = new CakeHouseMenu();
        DinerMenu   mDinerMenu = new DinerMenu();

        // 添加集合对象到迭代器的集合中
        mWaitress.addIterator(mCakeHouseMenu.getIterator());
        mWaitress.addIterator(mDinerMenu.getIterator());
        mWaitress.printMenu();
    }
}

四、Java内置的迭代器

Java提供了内置的迭代器Iterator

1.ArrayList已经集成了内部的迭代器，可直接使用

2.数组没有集成迭代器，则需要重新实现迭代器的方法

    /**
     * 实现Java内部的迭代器，重写迭代方法
     */
    class DinerIterator implements Iterator {
        private int position = 0;

        @Override
        public boolean hasNext() {
            if (position < numberOfItems) {
                return true;
            }
            position = 0;
            return false;
        }

        @Override
        public Object next() {
            MenuItem menuItem = menuItems[position];
            position++;
            return menuItem;
        }

        @Override
        public void remove() {

        }

    }

3.若添加一种新的集合类型只要实现了迭代器方法，也可用统一的方式进行遍历

五、单一责任原则

一个类，应该只有一个引起它变化的原因。应该只有一个职责。每一个职责都是变化的一个轴线，如果一个类有一个以上的职责，这些职责就耦合在了一起。这会导致脆弱的设计。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。

例如：要实现逻辑和界面的分离。

Java设计模式所有示例代码，持续更新中