迭代器模式:提供一种方法顺序访问一个集合对象中的各个元素,而又不暴露其内部的表示。
[]类图
迭代器模式类图
组合模式类图
[]迭代器模式的实现
菜单项实体
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();
}
[]
()组合模式让我们能用树形方式创建对象的结构,树里面包含了组合以及个别对象。
()组合模式提供一个结构,可同时包容个别对象和组合对象。
()组合模式允许客户对个别对象及组合对象一视同仁。
()菜单项(叶结点)没有子元素,菜单(节点,组合)有子元素。