迭代器与组合模式

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

[]类图

迭代器模式类图

组合模式类图

[]迭代器模式的实现

菜单项实体

public class MenuItem {

private String name;
private String description;
private boolean vegetarian;
private double price;

public MenuItem() {
}

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 DinerMenuIterator implements Iterator {

private MenuItem[] menuItemArray;
private int position;

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

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

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

@Override
public void remove() {
    if (position < 0) {
        throw new IllegalStateException("You can't remove an item");
    }

    if (menuItemArray[position - 1] != null) {
        for (int i = position - 1; i < (menuItemArray.length - 1); i++) {
            menuItemArray[i] = menuItemArray[i + 1];
        }
        menuItemArray[menuItemArray.length - 1] = null;
    }
}
}

菜单接口

public interface Menu {

Iterator createIterator();
}

菜单实现类

public class PancakeHouseMenu implements Menu {

ArrayList<MenuItem> menuItemList;

public PancakeHouseMenu() {
    menuItemList = new ArrayList();

    addItem("Breakfast", "toast", true, 2.99);
    addItem("Breakfast", "pancakrs with fried eggs", false, 2.99);
    addItem("Soup of the day", "Pancakes made with fresh blueberries", true, 3.49);
    addItem("Waffles", "blurberries or strawberries", true, 3.59);
}

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

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

菜单实现类

public class DinerMenu implements Menu {

private static final int MAX_ITEMS = 6;
private int numberOfItems = 0;
private MenuItem[] menuItemArray;

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

    addItem("Vegetarin", "bacon with lettuce", true, 2.99);
    addItem("BLT", "tomato on whole wheat", false, 2.99);
    addItem("Soup of the day", "with a side of potato salad", false, 3.29);
    addItem("Hotdog", "topped 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.out.println("Sorry,menu is full! Can't add item to menu");
    } else {
        menuItemArray[numberOfItems] = menuItem;
        numberOfItems++;
    }
}

@Override
public Iterator createIterator() {
    return new DinerMenuIterator(menuItemArray);
}

}

菜单实现类

public class CafeMenu implements Menu {

private HashMap<String, MenuItem> menuMap;

public CafeMenu() {
    menuMap = new HashMap();

    addItem("Air Fries", "lettuce,tomato,and fries", true, 3.99);
    addItem("Soup of the day", "with a side salad", false, 3.69);
    addItem("Burrito", "salsa, guacamole", true, 4.29);
}

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

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

服务类

public class Waitress {

private ArrayList<Menu> menuList;

public Waitress(ArrayList<Menu> menuList) {
    this.menuList = menuList;
}

public void printMenu() {
    Iterator<Menu> menuIterator = menuList.iterator();

    while (menuIterator.hasNext()) {
        Menu menu = menuIterator.next();
        printMenu(menu.createIterator());
        System.out.println("****************");
    }
}

public void printMenu(Iterator iterator) {
    while (iterator.hasNext()) {
        MenuItem menuItem = (MenuItem) iterator.next();
        System.out.println("name: " + menuItem.getName());
        System.out.println("description: " + menuItem.getDescription());
        System.out.println("price: " + menuItem.getPrice());
    }
}
}

测试

public static void main(String args[]) {
    Menu pancakeHouseMenu = new PancakeHouseMenu();
    Menu dinerMenu = new DinerMenu();
    Menu cafeMenu = new CafeMenu();

    ArrayList<Menu> menuList = new ArrayList();
    menuList.add(pancakeHouseMenu);
    menuList.add(dinerMenu);
    menuList.add(cafeMenu);

    Waitress waitress = new Waitress(menuList);
    waitress.printMenu();
}

[]
()迭代器模式依赖于一个迭代器的接口。
()迭代器模式把在元素之间游走的责任交给迭代器，而不是集合对象。这不仅让集合的接口和实现变得简洁，也可以让集合更专注在其它事情上，而不必理会遍历事情。
()迭代器模式将遍历集合的工作封装进一个对象中。

组合模式：允许你将对象组合成树形结构来表现”整体/部分”层次结构，组合能让客户以一致的方式处理个别对象以及对象组合。

[]类图

[]组合模式的实现

空迭代器

public class NullIterator implements Iterator {

@Override
public boolean hasNext() {
    return false;
}

@Override
public Object next() {
    return null;
}

@Override
public void remove() {
    throw new UnsupportedOperationException();
}
}

组合迭代器

public class ComponentIterator implements Iterator {

private Stack<Iterator> stack = new Stack();

public ComponentIterator(Iterator iterator) {
    stack.push(iterator);
}

@Override
public boolean hasNext() {
    if (stack.empty()) {
        return false;
    } else {
        Iterator iterator = stack.peek();
        if (!iterator.hasNext()) {
            stack.pop();
            return hasNext();
        } else {
            return true;
        }
    }
}

@Override
public Object next() {
    if (hasNext()) {
        Iterator<MenuComponent> iterator = stack.peek();
        MenuComponent menuComponent = iterator.next();
        if (menuComponent instanceof Menu) {
            stack.push(menuComponent.createIterator());
        }
        return menuComponent;
    } else {
        return null;
    }
}

@Override
public void remove() {
    throw new UnsupportedOperationException();
}
}

菜单组件抽象类

public abstract class MenuComponent {

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 String getName() {
    throw new UnsupportedOperationException();
}

public String getDescription() {
    throw new UnsupportedOperationException();
}

public double getPrice() {
    throw new UnsupportedOperationException();
}

public boolean isVegetarian() {
    throw new UnsupportedOperationException();
}

public void print() {
    throw new UnsupportedOperationException();
}

abstract Iterator createIterator();

}

菜单实现类

public class Menu extends MenuComponent {

private ArrayList<MenuComponent> menuComponentList;
private String name;
private String description;

public Menu(String name, String description) {
    this.menuComponentList = new ArrayList();
    this.name = name;
    this.description = description;
}

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

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

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

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

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

@Override
public void print() {
    System.out.println("name: " + getName());
    System.out.println("escription: " + getDescription());

    Iterator<MenuComponent> menuComponentIterator = menuComponentList.iterator();
    while (menuComponentIterator.hasNext()) {
        MenuComponent menuComponent = menuComponentIterator.next();
        menuComponent.print();
    }

}

@Override
Iterator createIterator() {
    return new ComponentIterator(menuComponentList.iterator());
}
}

菜单项实现类

public class MenuItem extends MenuComponent {

private String name;
private String description;
private boolean vegetarian;
private double price;

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

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

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

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

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

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

    if (this.isVegetarian()) {
        System.out.println(" (V) ");
    }

    System.out.println("price: " + getPrice());
    System.out.println("escription: " + getDescription());
}

@Override
Iterator createIterator() {
    return new NullIterator();
}
}

服务类

public class Waitress {

private MenuComponent allMenus;

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

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

public void printVegetarianMenu() {

    Iterator<MenuComponent> iterator = allMenus.createIterator();

    while (iterator.hasNext()) {
        MenuComponent menuComponent = iterator.next();

        try {
            if (menuComponent.isVegetarian()) {
                menuComponent.print();
            }
        } catch (UnsupportedOperationException e) {
        }
    }
}
}

测试

public static void main(String args[]) {
    MenuComponent pancakeHouseMenu = new Menu("Pancake House Menu", "Breakfast");
    MenuComponent dinerMenu = new Menu("diner Menu", "Lunch");
    MenuComponent cafeMenu = new Menu("cafe Menu", "Dinner");
    MenuComponent desserrtMenu = new Menu("dessert Menu", "Dessert of course");

    MenuComponent allMenus = new Menu("all Menus", "All menus combined");

    allMenus.add(pancakeHouseMenu);
    allMenus.add(dinerMenu);
    allMenus.add(cafeMenu);

    dinerMenu.add(new MenuItem("Pasta", "sile of sourdough bread", true, 3.89));

    dinerMenu.add(desserrtMenu);

    desserrtMenu.add(new MenuItem("Apple Pie", "with vanilla ice cream", true, 1.59));

    Waitress waitress = new Waitress(allMenus);
    waitress.printMenu();

    waitress.printVegetarianMenu();
}

[]
()组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别对象。
()组合模式提供一个结构，可同时包容个别对象和组合对象。
()组合模式允许客户对个别对象及组合对象一视同仁。
()菜单项(叶结点)没有子元素，菜单(节点，组合)有子元素。