《Head First 设计模式》读书笔记——迭代器模式

最新推荐文章于 2021-02-26 14:33:38 发布

xsd9527

最新推荐文章于 2021-02-26 14:33:38 发布

阅读量152

点赞数

分类专栏： Java 文章标签：设计模式 java

本文链接：https://blog.csdn.net/qq_42909545/article/details/105024998

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

让客户遍历我们的数组、堆栈、列表或者散列表时，无法知道我们存储对象的方式，就靠今天的迭代器模式了。

案例

我们有两个餐饮店要合并经营，他们的菜品有共同的地方，所以我们这两个商店类需要一个共同的菜单属性，我们单独创建一个菜单类，如下。

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

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

    public String getName() {
        return name;
    }

    public String getDescription() {
        return description;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public double getPrice() {
        return price;
    }
}

现在来看两个商店类。

public class DinerMenu {
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];

        addItem("Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat",
                true,
                2.99);
        addItem("BLT",
                "Bacon with lettuce & tomato on whole wheat",
                false,
                2.99);
        addItem("Soup of the day",
                "Soup of the day, with a side of potato salad",
                false,
                3.29);
        addItem("Hotdog",
                "A hot dog, with saurkraut, relish, onions, toped with cheese",
                false,
                3.05);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("Sorry, menu is full! Can't add item to menu");
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems += 1;
        }
    }

    public MenuItem[] getMenuItems() {
        return menuItems;
    }
}

public class PancakeHouseMenu {
    ArrayList menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList();
        addItem("K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99);
        addItem("Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99);
        addItem("Blueberry Pancakes",
                "Pancakes made with fresh blueberries",
                true,
                3.49);
        addItem("Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.add(menuItem);
    }

    public ArrayList getMenuItems() {
        return menuItems;
    }
}

结构是类似的，都有一个菜单属性，不过一个是集合，一个是数组，在初始化的时候添加几样菜品，还有一个返回菜单的 getter() 方法。

接下来是我们要操作的重头戏，女侍者类，里面有打印菜单的方法。

public class Waitress {

    public void printMenu() {
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();

        ArrayList houseMenuMenuItems = pancakeHouseMenu.getMenuItems();
        MenuItem[] dinerMenuMenuItems = dinerMenu.getMenuItems();

        // 循环遍历
        for (int i = 0; i < houseMenuMenuItems.size(); i++) {
            MenuItem menuItem = (MenuItem) houseMenuMenuItems.get(i);
            System.out.println(menuItem.getName() + " ");
            System.out.println(menuItem.getPrice() + " ");
            System.out.println(menuItem.getDescription());
        }

        for (int i = 0; i < dinerMenuMenuItems.length; i++) {
            MenuItem dinerMenuMenuItem = dinerMenuMenuItems[i];
            System.out.println(dinerMenuMenuItem.getName() + " ");
            System.out.println(dinerMenuMenuItem.getPrice() + " ");
            System.out.println(dinerMenuMenuItem.getDescription());
        }
    }
}

这是最简单的使用 for 循环遍历，假如我们又有新的店家要联合开店，就要在这个方法中继续增加 for 循环遍历，很重复很冗余，我们应该封装变化的部分，我们来就使用迭代器模式来改进。首先创建一个迭代器接口。

public interface Iterator {
    boolean hasNext();
    Object next();
}

然后分别创建集合与数组的迭代器类，他们实现上面的方法，一个是判断是否仍有下一个元素 hasNext() 方法，一个是返回下一个元素的 next() 方法。

public class DinerMenuIterator implements Iterator {
    MenuItem[] items;
    int position = 0;

    public DinerMenuIterator(MenuItem[] items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        if (position >= items.length || items[position] == null) {
            return false;
        } else {
            return true;
        }
    }

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

public class PancakeHouseMenuIterator implements Iterator {
    ArrayList items;
    int position = 0;

    public PancakeHouseMenuIterator(ArrayList items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        if (position >= items.size() || items.get(position) == null) {
            return false;
        } else {
            return true;
        }
    }

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

然后修改两个菜单类，删除掉 getMenuItems() 方法，因为这会暴露我们代码内部的实现，然后添加一个返回迭代器的方法，我们通过这个迭代器进行数据的遍历。

public class DinerMenu {
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];

        addItem("Vegetarian BLT",
                "(Fakin') Bacon with lettuce & tomato on whole wheat",
                true,
                2.99);
        addItem("BLT",
                "Bacon with lettuce & tomato on whole wheat",
                false,
                2.99);
        addItem("Soup of the day",
                "Soup of the day, with a side of potato salad",
                false,
                3.29);
        addItem("Hotdog",
                "A hot dog, with saurkraut, relish, onions, toped with cheese",
                false,
                3.05);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("Sorry, menu is full! Can't add item to menu");
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems += 1;
        }
    }

    public Iterator createIterator() {
        return new DinerMenuIterator(menuItems);
    }
}

public class PancakeHouseMenu {
    ArrayList menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList();
        addItem("K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99);
        addItem("Regular Pancake Breakfast",
                "Pancakes with fried eggs, sausage",
                false,
                2.99);
        addItem("Blueberry Pancakes",
                "Pancakes made with fresh blueberries",
                true,
                3.49);
        addItem("Waffles",
                "Waffles, with your choice of blueberries or strawberries",
                true,
                3.59);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.add(menuItem);
    }

    public Iterator creatorIterator() {
        return new PancakeHouseMenuIterator(menuItems);
    }
}

最后就是我们的女侍者类了，创建一个私有方法，用以利用迭代器对数据进行遍历，再修改打印菜单方法，利用刚刚的 creatorIterator() 方法返回迭代器，配合私有方法进行遍历数据。

public class Waitress {

    public void printMenu() {
        DinerMenu dinerMenu = new DinerMenu();
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        Iterator dinerIterator = dinerMenu.createIterator();
        Iterator pancakeIterator = pancakeHouseMenu.creatorIterator();
        System.out.println("MENU\n----\nBREAKFAST");
        printMenu(dinerIterator);
        System.out.println("\nLUNCH");
        printMenu(pancakeIterator);
    }

    private void printMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = (MenuItem)iterator.next();
            System.out.println(menuItem.getName() + " ");
            System.out.println(menuItem.getPrice() + " -- ");
            System.out.println(menuItem.getDescription());
        }
    }
}

我们不再需要 getMenuItem() 方法，删掉，取而代之是获取迭代器对象，然后使用下面的 printMenu(Iterator iterator) 方法。

这样我们只需要给他们两个迭代器，然后各自商店增加一个返回迭代器对象的方法就可以了。这样我们的女侍者很容易扩展和维护，当新增商店时，只需要创建这个商店对象，返回它的迭代器，调用 printMenu(Iterator iterator) 方法。

这个迭代器让我们把女侍者从具体类的实现中解耦，她不需要知道菜单使用的是什么数据结构，只要知道她可以拿到迭代器即可。迭代器使我们可以遍历聚合中的每个元素，而不是必须在方法内实现遍历，只是让我们能在数据聚合中访问到每个元素，我们封装了遍历。

我们继续改进我们的设计，事实上，ArrayList 已经为我们提供了一个获取 Iterator 的方法，所以我们修改一下 PancakeHouseMenu 的 createIterator() 方法，先导入 java.util.Iterator，我们使用 Java 提供的迭代器接口。

public Iterator creatorIterator() {
        return menuItems.iterator();
    }

下面我们修改 DinerMenu，使其满足 java.util.Iterator 接口的需求，这需要从 DinerMenuIterator 开始修改。导入 java.util.Iterator，实现 remove() 方法。

public class DinerMenuIterator implements Iterator {
    MenuItem[] items;
    int position = 0;

    public DinerMenuIterator(MenuItem[] items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        if (position >= items.length || items[position] == null) {
            return false;
        } else {
            return true;
        }
    }

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

    @Override
    public void remove() {
        if (position <= 0) {
            throw new IllegalStateException("You can't remove an item until you've done at least one next()");
        }
        if (items[position - 1] != null) {
            for (int i = position - 1; i < items.length - 1; i++) {
                items[i] = items[i+1];
            }
            items[items.length-1] = null;
        }
    }
}

然后在 DinerMenu 中添加导入 java.util.Iterator。我们还可以通过添加 Menu 接口，令两个餐厅菜单类实现这个接口，方便我们在侍女类中的方法调用，这样我们是面向接口编程，降低具体实现和侍女类的耦合。

public interface Menu {
    public Iterator createIterator();
}

public class DinerMenu implements Menu {...}

public class PancakeHouseMenu implements Menu {...}

实现这个接口后，我们再看侍女类。

public class Waitress {

    public void printMenu() {
        Menu dinerMenu = new DinerMenu();
        Menu pancakeHouseMenu = new PancakeHouseMenu();
        Iterator dinerIterator = dinerMenu.createIterator();
        Iterator pancakeIterator = pancakeHouseMenu.createIterator();
        System.out.println("MENU\n----\nBREAKFAST");
        printMenu(dinerIterator);
        System.out.println("\nLUNCH");
        printMenu(pancakeIterator);
    }

    private void printMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = (MenuItem)iterator.next();
            System.out.println(menuItem.getName() + " ");
            System.out.println(menuItem.getPrice() + " -- ");
            System.out.println(menuItem.getDescription());
        }
    }
}

导入 java.util.Iterator，使用 Menu 声明两个菜单类，而不具体类，「针对接口编程，而不是针对实现编程」。我们就可以减少女招待和具体类之间的依赖。

迭代器模式定义

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

迭代器模式让我们可以遍历数据集内的每一个元素，且又不暴露其的数据结构，把元素遍历的责任交给迭代器，而不是聚合对象，这让聚合的接口和实现变得更简洁，也可以让聚合更专注于它所应完成的任务，而不用理会遍历数据的事情。

「单一责任」设计原则：一个类应该只有一个引起变化的原因。

应该避免类的改变，因为修改代码很容易造成许多潜在的错误。如果有一个类具有两个改变的原因，那么这个类改变的几率就会上升，而当它真正有改变的时候，这两方面都会受到影响，所以我们就按照这个原则，只将一个责任指派给一个类。

我们要学会的就是区分设计中的责任，这是很困难的，看着一大群的行为，然后将它们集中在一起，尽管他们可能属于两个或多个不同的责任，但我们努力不懈地检查自己的设计，随着系统的成长，随时观察我们的类改变的原因是否存在超过一个。

新增咖啡厅

现在我们要新增一个咖啡厅到我们的系统，那么该如何设计呢？

public class CafeMenu implements Menu {
    Hashtable menuItems = new Hashtable();

    public CafeMenu() {
        addItem("Veggie Burger and Air Fries",
                "Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
                true,
                3.99);
        addItem("Soup of the day",
                "A cup of the soup of the day, with a side salad",
                false,
                3.69);
        addItem("Burrito",
                "A large burrito, with whole pinto beans, salsa, guacamole",
                true,
                4.29);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.put(menuItem.getName(), menuItem);
    }

    @Override
    public Iterator createIterator() {
        return menuItems.values().iterator();
    }
}

这是咖啡菜单类，和前面两个菜单类很类似，都是实现菜单接口，返回迭代器。然后再在女侍者类的 printMenu() 方法添加几行，创建咖啡菜单类，获取迭代器，调用 printMenu(Iterator iterator) 方法遍历数据。

public void printMenu() {
        Menu dinerMenu = new DinerMenu();
        Menu pancakeHouseMenu = new PancakeHouseMenu();
        CafeMenu cafeMenu = new CafeMenu();
        Iterator dinerIterator = dinerMenu.createIterator();
        Iterator pancakeIterator = pancakeHouseMenu.createIterator();
        Iterator cafeMenuIterator = cafeMenu.createIterator();
        System.out.println("MENU\n----\nBREAKFAST");
        printMenu(dinerIterator);
        System.out.println("\nLUNCH");
        printMenu(pancakeIterator);
        System.out.println("\nDINNER");
        printMenu(cafeMenuIterator);
    }

这样即可完成添加新的菜单的目的了，但是还有一个问题，程序中多次调用 printMenu()，实在是不美观，而且每次新增加菜单，还要打开女侍者类新增更多代码，我们如何修改这个设计呢？来看代码：

public class Waitress {

    ArrayList menus;

    public Waitress(ArrayList menus) {
        this.menus = menus;
    }

    public void printMenu() {
        Iterator iterator = menus.iterator();
        while (iterator.hasNext()) {
            Menu next = (Menu) iterator.next();
            printMenu(next.createIterator());
        }
    }

    private void printMenu(Iterator iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = (MenuItem)iterator.next();
            System.out.println(menuItem.getName() + " ");
            System.out.println(menuItem.getPrice() + " -- ");
            System.out.println(menuItem.getDescription());
        }
    }
}

做一个菜单类集合属性，当我们调试的时候只需要给女侍者对象传入一个菜单集合，然后再在 printMenu() 方法中遍历这个集合就可以让我们代码更简便。

现在他们希望在后面加上一份餐后甜点的「子菜单」。有点类似于一棵树的结构，我们不能把甜点菜单赋值给菜单项数组，所以又要修改了！修改见下篇博客。