设计模式学习--迭代器模式(Iterator Pattern)和组合模式（Composite Pattern)
2013-09-06 16:23
651 查看
http://blog.csdn.net/wwj_748/article/details/9259031
设计模式学习--迭代器模式(Iterator Pattern)
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示
把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。
组合模式允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。
封装变化
多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合设计而努力
类应该对扩展开放，对修改关闭
依赖抽象，不要依赖具体类
只和朋友交谈
别找我，我会找你
类应该只有一个改变的理由
迭代器允许访问聚合的元素，而不需要暴露它的内部结构
迭代器将遍历聚合的工作封装进一个对象中。
当使用迭代器的时候，我们依赖聚合提供遍历。
迭代器提供一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态机制。
我们应该努力让一个类分配一个责任。
组合模式提供一个结构，可同时包容个别对象和组合对象。
组合模式允许客户对个别对象以及组合对象一视同仁。
组合结构内的任意对象成为组件，组件可以是组合，也可以是叶节点。
在实现组合模式时，有许多设计上的折衷。你要根据需要平衡透明性和安全性。
自定义迭代器
Iterator
[java] view
plaincopyprint?
package dinermerger;
/**
* 自定义迭代器接口
* @author wwj
*
*/
public interface Iterator {
boolean hasNext(); //是否还有下一个元素
Object next(); //返回下一个元素
}
实现迭代器
DinerMenuIterator
[java] view
plaincopyprint?
package dinermerger;
/**
* 实现一个具体的迭代器，为餐厅菜单服务
* @author Administrator
*
*/
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 = position + 1;
return menuItem;
}
}
PancakeHouseMenuIterator
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
public class PancakeHouseMenuIterator implements Iterator{
ArrayList menuItems;
int position = 0;
public PancakeHouseMenuIterator(ArrayList menuItems) {
this.menuItems = menuItems;
}
@Override
public boolean hasNext() {
if(position >= menuItems.size()) {
return false;
} else {
return true;
}
}
@Override
public Object next() {
Object object = menuItems.get(position);
position = position + 1;
return object;
}
}
菜单项
[java] view
plaincopyprint?
package dinermerger;
/**
* 菜单项
* @author wwj
*
*/
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 double getPrice() {
return price;
}
public boolean isVegetarian() {
return vegetarian;
}
}
菜单
PancakeHouseMenu
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
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);
}
/**
* 创建一个新的菜单项对象，传入每一个变量，然后将它加入到ArrayList中
* @param name 菜名
* @param description 叙述
* @param vegetarian 是否为素食
* @param price 价格
*/
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;
}*/
public Iterator createIterator() {
return new PancakeHouseMenuIterator(menuItems);
}
}
DinerMenu
[java] view
plaincopyprint?
package dinermerger;
/**
* 餐厅菜单
* @author wwj
*
*/
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, topped with cheese",
false, 3.05);
addItem("Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice", true, 3.99);
addItem("Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true, 3.89);
}
private 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 = numberOfItems + 1;
}
}
/**
* 增加了迭代器之后，这个方法就不需要了
* @return
*/
/*public MenuItem[] getMenuItems() {
return menuItems;
}*/
/**
* 用来从菜单项数组创建一个DinerMenuIterator,并将它返回给客户
*/
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
}
女招待
[java] view
plaincopyprint?
package dinermerger;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
PancakeHouseMenu pancakeHouseMenu;
DinerMenu dinerMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(PancakeHouseMenu pancakeHouseMenu, DinerMenu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
测试
[java] view
plaincopyprint?
package dinermerger;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
DinerMenu dinerMenu = new DinerMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
waitress.printMenu();
}
}
结果：
MENU
----
BREAKFAST
K&B's Pancake Breakfast, 2.99 -- Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast, 2.99 -- Pancakes with fried eggs, sausage
Blueberry Pancakes, 3.49 -- Pancakes made with fresh blueberries
Waffles, 3.59 -- Waffles, with your choice of blueberries or strawberries
LUNCH
Vegetarian BLT, 2.99 -- (Fakin') Bacon with lettuce & tomato on Whole wheat
BLT, 2.99 -- Bacon with lettuce & tomato on Whole wheat
Soup of the day, 3.29 -- Soup of the day, with a side of potato salad
Hotdog, 3.05 -- A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice, 3.99 -- Steamed vegetables over brown rice
Pasta, 3.89 -- Spaghetti with Marinara Sauce, and a slice of sourdough bread
利用java.util.Iterator来实现迭代器
提供一个Menu接口，让PancakeHouseMenu和DinerMenu都实现Menu接口，这样Waitress就不用依赖具体的菜单的问题，也不用依赖菜单项的具体实现了。
[java] view
plaincopyprint?
package dinermerger;
/**
* 这是一个简单的接口，让客户能够取得菜单项
* @author Administrator
*
*/
public interface Menu {
public Iterator createIterator();
}
DinerMenu
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 餐厅菜单
* @author wwj
*
*/
public class DinerMenu implements Menu{
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, topped with cheese",
false, 3.05);
addItem("Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice", true, 3.99);
addItem("Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true, 3.89);
}
private 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 = numberOfItems + 1;
}
}
/**
* 增加了迭代器之后，这个方法就不需要了
* @return
*/
/*public MenuItem[] getMenuItems() {
return menuItems;
}*/
/**
* 用来从菜单项数组创建一个DinerMenuIterator,并将它返回给客户
*/
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
}
PancakeHouseMenu
不创建自己的迭代器，而是调用ArrayList的iterator()方法
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
public class PancakeHouseMenu implements Menu{
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);
}
/**
* 创建一个新的菜单项对象，传入每一个变量，然后将它加入到ArrayList中
* @param name 菜名
* @param description 叙述
* @param vegetarian 是否为素食
* @param price 价格
*/
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;
}*/
public Iterator createIterator() {
return menuItems.iterator();
}
}
DinerMenuIterator
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 实现一个具体的迭代器，为餐厅菜单服务
* @author Administrator
*
*/
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 = 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 on 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;
}
}
}
Waitress
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
Menu pancakeHouseMenu;
Menu dinerMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
增加一个CafeMenu会变成以下这样
[java] view
plaincopyprint?
package dinermerger;
import java.util.Hashtable;
import java.util.Iterator;
/**
* 咖啡厅菜单
* @author wwj
*
*/
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();
}
}
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
Menu pancakeHouseMenu;
Menu dinerMenu;
Menu cafeMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
/**
* 新增一个cafeMenu
* @param pancakeHouseMenu
* @param dinerMenu
* @param cafeMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
this.cafeMenu = cafeMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
Iterator cafeIterator = cafeMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
System.out.println("\nDINNER");
printMenu(cafeIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
Test
[java] view
plaincopyprint?
package dinermerger;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
// PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
// DinerMenu dinerMenu = new DinerMenu();
//
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
//
// waitress.printMenu();
Menu pancakeHouseMenu = new PancakeHouseMenu();
Menu dinerMenu = new DinerMenu();
Menu cafeMenu = new CafeMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu, cafeMenu);
waitress.printMenu();
}
}
结果：
MENU
----
BREAKFAST
K&B's Pancake Breakfast, 2.99 -- Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast, 2.99 -- Pancakes with fried eggs, sausage
Blueberry Pancakes, 3.49 -- Pancakes made with fresh blueberries
Waffles, 3.59 -- Waffles, with your choice of blueberries or strawberries
LUNCH
Vegetarian BLT, 2.99 -- (Fakin') Bacon with lettuce & tomato on Whole wheat
BLT, 2.99 -- Bacon with lettuce & tomato on Whole wheat
Soup of the day, 3.29 -- Soup of the day, with a side of potato salad
Hotdog, 3.05 -- A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice, 3.99 -- Steamed vegetables over brown rice
Pasta, 3.89 -- Spaghetti with Marinara Sauce, and a slice of sourdough bread
DINNER
Soup of the day, 3.69 -- A cup of the soup of the day, with a side salad
Burrito, 4.29 -- A large burrito, with whole pinto beans, salsa, guacamole
Veggie Burger and Air Fries, 3.99 -- Veggie burger on a whole wheat bun, lettuce, tomato, and fries
为了让女招待更加有扩展性，我们这样做
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
// Menu pancakeHouseMenu;
// Menu dinerMenu;
// Menu cafeMenu;
ArrayList menus;
/* *//**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*//*
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
*//**
* 新增一个cafeMenu
* @param pancakeHouseMenu
* @param dinerMenu
* @param cafeMenu
*//*
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
this.cafeMenu = cafeMenu;
}*/
public Waitress(ArrayList menus) {
this.menus = menus;
}
public void printMenu() {
/* Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
Iterator cafeIterator = cafeMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
System.out.println("\nDINNER");
printMenu(cafeIterator);*/
Iterator menuIterator = menus.iterator();
while(menuIterator.hasNext()) {
Menu menu = (Menu)menuIterator.next();
printMenu(menu.createIterator());
}
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
测试的时候我们就可以这样
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
// PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
// DinerMenu dinerMenu = new DinerMenu();
//
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
//
// waitress.printMenu();
Menu pancakeHouseMenu = new PancakeHouseMenu();
Menu dinerMenu = new DinerMenu();
Menu cafeMenu = new CafeMenu();
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu, cafeMenu);
ArrayList menus = new ArrayList();
menus.add(pancakeHouseMenu);
menus.add(dinerMenu);
menus.add(cafeMenu);
Waitress waitress = new Waitress(menus);
waitress.printMenu();
}
}
总算是要讲到组合模式了，这个模式可以解决迭代器模式中不能解决的一个难题。比如我们需要一个新的餐单，菜单下又有子菜单，单单用迭代器就不能解决了。这时候可以考虑到用树形结构来展示整个菜单。
看下面的例子吧：
定义菜单组件
[java] view
plaincopyprint?
package composite;
/**
* 定义菜单组件
* @author Administrator
*
*/
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();
}
}
实现菜单
[java] view
plaincopyprint?
package composite;
import java.util.ArrayList;
import java.util.Iterator;
public class Menu extends MenuComponent{
ArrayList menuComponents = new ArrayList();
String name;
String description;
public Menu(String name, String description) {
this.name = name;
this.description = description;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return (MenuComponent) menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public void print(){
System.out.print("\n" + getName());
System.out.println(", " + getDescription());
System.out.println("------------------");
Iterator iterator = menuComponents.iterator();
while(iterator.hasNext()) {
MenuComponent menuComponent =
(MenuComponent) iterator.next();
menuComponent.print();
}
}
}
实现菜单项
[java] view
plaincopyprint?
package composite;
/**
* 实现菜单项
* @author Administrator
*
*/
public class MenuItem extends MenuComponent{
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 void print(){
System.out.print(" " + getName());
if(isVegetarian()) {
System.out.print("(v)");
}
System.out.println("," + getPrice());
System.out.println(" --" + getDescription());
}
}
变得十分快乐的女招待
[java] view
plaincopyprint?
package composite;
import java.util.Iterator;
public class Waitress {
MenuComponent allMenus;
public Waitress(MenuComponent allMenus) {
this.allMenus = allMenus;
}
public void printMenu() {
allMenus.print();
}
}
我们这样测试
[java] view
plaincopyprint?
package composite;
import java.util.*;
public class MenuTestDrive {
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 dessertMenu =
new Menu("DESSERT MENU", "Dessert of course!");
MenuComponent coffeeMenu = new Menu("COFFEE MENU", "Stuff to go with your afternoon coffee");
MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");
allMenus.add(pancakeHouseMenu);
allMenus.add(dinerMenu);
allMenus.add(cafeMenu);
pancakeHouseMenu.add(new MenuItem(
"K&B's Pancake Breakfast",
"Pancakes with scrambled eggs, and toast",
true,
2.99));
pancakeHouseMenu.add(new MenuItem(
"Regular Pancake Breakfast",
"Pancakes with fried eggs, sausage",
false,
2.99));
pancakeHouseMenu.add(new MenuItem(
"Blueberry Pancakes",
"Pancakes made with fresh blueberries, and blueberry syrup",
true,
3.49));
pancakeHouseMenu.add(new MenuItem(
"Waffles",
"Waffles, with your choice of blueberries or strawberries",
true,
3.59));
dinerMenu.add(new MenuItem(
"Vegetarian BLT",
"(Fakin') Bacon with lettuce & tomato on whole wheat",
true,
2.99));
dinerMenu.add(new MenuItem(
"BLT",
"Bacon with lettuce & tomato on whole wheat",
false,
2.99));
dinerMenu.add(new MenuItem(
"Soup of the day",
"A bowl of the soup of the day, with a side of potato salad",
false,
3.29));
dinerMenu.add(new MenuItem(
"Hotdog",
"A hot dog, with saurkraut, relish, onions, topped with cheese",
false,
3.05));
dinerMenu.add(new MenuItem(
"Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice",
true,
3.99));
dinerMenu.add(new MenuItem(
"Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true,
3.89));
dinerMenu.add(dessertMenu);
dessertMenu.add(new MenuItem(
"Apple Pie",
"Apple pie with a flakey crust, topped with vanilla icecream",
true,
1.59));
dessertMenu.add(new MenuItem(
"Cheesecake",
"Creamy New York cheesecake, with a chocolate graham crust",
true,
1.99));
dessertMenu.add(new MenuItem(
"Sorbet",
"A scoop of raspberry and a scoop of lime",
true,
1.89));
cafeMenu.add(new MenuItem(
"Veggie Burger and Air Fries",
"Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
true,
3.99));
cafeMenu.add(new MenuItem(
"Soup of the day",
"A cup of the soup of the day, with a side salad",
false,
3.69));
cafeMenu.add(new MenuItem(
"Burrito",
"A large burrito, with whole pinto beans, salsa, guacamole",
true,
4.29));
cafeMenu.add(coffeeMenu);
coffeeMenu.add(new MenuItem(
"Coffee Cake",
"Crumbly cake topped with cinnamon and walnuts",
true,
1.59));
coffeeMenu.add(new MenuItem(
"Bagel",
"Flavors include sesame, poppyseed, cinnamon raisin, pumpkin",
false,
0.69));
coffeeMenu.add(new MenuItem(
"Biscotti",
"Three almond or hazelnut biscotti cookies",
true,
0.89));
Waitress waitress = new Waitress(allMenus);
waitress.printMenu();
}
}
测试结果：
ALL MENUS, All menus combined
------------------
PANCAKE HOUSE MENU, Breakfast
------------------
K&B's Pancake Breakfast(v),2.99
--Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast,2.99
--Pancakes with fried eggs, sausage
Blueberry Pancakes(v),3.49
--Pancakes made with fresh blueberries, and blueberry syrup
Waffles(v),3.59
--Waffles, with your choice of blueberries or strawberries
DINER MENU, Lunch
------------------
Vegetarian BLT(v),2.99
--(Fakin') Bacon with lettuce & tomato on whole wheat
BLT,2.99
--Bacon with lettuce & tomato on whole wheat
Soup of the day,3.29
--A bowl of the soup of the day, with a side of potato salad
Hotdog,3.05
--A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice(v),3.99
--Steamed vegetables over brown rice
Pasta(v),3.89
--Spaghetti with Marinara Sauce, and a slice of sourdough bread
DESSERT MENU, Dessert of course!
------------------
Apple Pie(v),1.59
--Apple pie with a flakey crust, topped with vanilla icecream
Cheesecake(v),1.99
--Creamy New York cheesecake, with a chocolate graham crust
Sorbet(v),1.89
--A scoop of raspberry and a scoop of lime
CAFE MENU, Dinner
------------------
Veggie Burger and Air Fries(v),3.99
--Veggie burger on a whole wheat bun, lettuce, tomato, and fries
Soup of the day,3.69
--A cup of the soup of the day, with a side salad
Burrito(v),4.29
--A large burrito, with whole pinto beans, salsa, guacamole
COFFEE MENU, Stuff to go with your afternoon coffee
------------------
Coffee Cake(v),1.59
--Crumbly cake topped with cinnamon and walnuts
Bagel,0.69
--Flavors include sesame, poppyseed, cinnamon raisin, pumpkin
Biscotti(v),0.89
--Three almond or hazelnut biscotti cookies
设计模式学习--迭代器模式(Iterator Pattern)
概述
———————————————————————————————————————————————————迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示
把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。
组合模式允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。
OO原则
———————————————————————————————————————————————————封装变化
多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合设计而努力
类应该对扩展开放，对修改关闭
依赖抽象，不要依赖具体类
只和朋友交谈
别找我，我会找你
类应该只有一个改变的理由
要点
———————————————————————————————————————————————————迭代器允许访问聚合的元素，而不需要暴露它的内部结构
迭代器将遍历聚合的工作封装进一个对象中。
当使用迭代器的时候，我们依赖聚合提供遍历。
迭代器提供一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态机制。
我们应该努力让一个类分配一个责任。
组合模式提供一个结构，可同时包容个别对象和组合对象。
组合模式允许客户对个别对象以及组合对象一视同仁。
组合结构内的任意对象成为组件，组件可以是组合，也可以是叶节点。
在实现组合模式时，有许多设计上的折衷。你要根据需要平衡透明性和安全性。
例子1
———————————————————————————————————————————————————自定义迭代器
Iterator
[java] view
plaincopyprint?
package dinermerger;
/**
* 自定义迭代器接口
* @author wwj
*
*/
public interface Iterator {
boolean hasNext(); //是否还有下一个元素
Object next(); //返回下一个元素
}
实现迭代器
DinerMenuIterator
[java] view
plaincopyprint?
package dinermerger;
/**
* 实现一个具体的迭代器，为餐厅菜单服务
* @author Administrator
*
*/
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 = position + 1;
return menuItem;
}
}
PancakeHouseMenuIterator
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
public class PancakeHouseMenuIterator implements Iterator{
ArrayList menuItems;
int position = 0;
public PancakeHouseMenuIterator(ArrayList menuItems) {
this.menuItems = menuItems;
}
@Override
public boolean hasNext() {
if(position >= menuItems.size()) {
return false;
} else {
return true;
}
}
@Override
public Object next() {
Object object = menuItems.get(position);
position = position + 1;
return object;
}
}
菜单项
[java] view
plaincopyprint?
package dinermerger;
/**
* 菜单项
* @author wwj
*
*/
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 double getPrice() {
return price;
}
public boolean isVegetarian() {
return vegetarian;
}
}
菜单
PancakeHouseMenu
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
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);
}
/**
* 创建一个新的菜单项对象，传入每一个变量，然后将它加入到ArrayList中
* @param name 菜名
* @param description 叙述
* @param vegetarian 是否为素食
* @param price 价格
*/
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;
}*/
public Iterator createIterator() {
return new PancakeHouseMenuIterator(menuItems);
}
}
DinerMenu
[java] view
plaincopyprint?
package dinermerger;
/**
* 餐厅菜单
* @author wwj
*
*/
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, topped with cheese",
false, 3.05);
addItem("Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice", true, 3.99);
addItem("Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true, 3.89);
}
private 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 = numberOfItems + 1;
}
}
/**
* 增加了迭代器之后，这个方法就不需要了
* @return
*/
/*public MenuItem[] getMenuItems() {
return menuItems;
}*/
/**
* 用来从菜单项数组创建一个DinerMenuIterator,并将它返回给客户
*/
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
}
女招待
[java] view
plaincopyprint?
package dinermerger;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
PancakeHouseMenu pancakeHouseMenu;
DinerMenu dinerMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(PancakeHouseMenu pancakeHouseMenu, DinerMenu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
测试
[java] view
plaincopyprint?
package dinermerger;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
DinerMenu dinerMenu = new DinerMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
waitress.printMenu();
}
}
结果：
MENU
----
BREAKFAST
K&B's Pancake Breakfast, 2.99 -- Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast, 2.99 -- Pancakes with fried eggs, sausage
Blueberry Pancakes, 3.49 -- Pancakes made with fresh blueberries
Waffles, 3.59 -- Waffles, with your choice of blueberries or strawberries
LUNCH
Vegetarian BLT, 2.99 -- (Fakin') Bacon with lettuce & tomato on Whole wheat
BLT, 2.99 -- Bacon with lettuce & tomato on Whole wheat
Soup of the day, 3.29 -- Soup of the day, with a side of potato salad
Hotdog, 3.05 -- A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice, 3.99 -- Steamed vegetables over brown rice
Pasta, 3.89 -- Spaghetti with Marinara Sauce, and a slice of sourdough bread
例子2
———————————————————————————————————————————————————利用java.util.Iterator来实现迭代器
提供一个Menu接口，让PancakeHouseMenu和DinerMenu都实现Menu接口，这样Waitress就不用依赖具体的菜单的问题，也不用依赖菜单项的具体实现了。
[java] view
plaincopyprint?
package dinermerger;
/**
* 这是一个简单的接口，让客户能够取得菜单项
* @author Administrator
*
*/
public interface Menu {
public Iterator createIterator();
}
DinerMenu
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 餐厅菜单
* @author wwj
*
*/
public class DinerMenu implements Menu{
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, topped with cheese",
false, 3.05);
addItem("Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice", true, 3.99);
addItem("Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true, 3.89);
}
private 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 = numberOfItems + 1;
}
}
/**
* 增加了迭代器之后，这个方法就不需要了
* @return
*/
/*public MenuItem[] getMenuItems() {
return menuItems;
}*/
/**
* 用来从菜单项数组创建一个DinerMenuIterator,并将它返回给客户
*/
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
}
PancakeHouseMenu
不创建自己的迭代器，而是调用ArrayList的iterator()方法
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 煎饼屋菜单实现
* @author wwj
*
*/
public class PancakeHouseMenu implements Menu{
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);
}
/**
* 创建一个新的菜单项对象，传入每一个变量，然后将它加入到ArrayList中
* @param name 菜名
* @param description 叙述
* @param vegetarian 是否为素食
* @param price 价格
*/
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;
}*/
public Iterator createIterator() {
return menuItems.iterator();
}
}
DinerMenuIterator
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 实现一个具体的迭代器，为餐厅菜单服务
* @author Administrator
*
*/
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 = 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 on 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;
}
}
}
Waitress
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
Menu pancakeHouseMenu;
Menu dinerMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
增加一个CafeMenu会变成以下这样
[java] view
plaincopyprint?
package dinermerger;
import java.util.Hashtable;
import java.util.Iterator;
/**
* 咖啡厅菜单
* @author wwj
*
*/
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();
}
}
[java] view
plaincopyprint?
package dinermerger;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
Menu pancakeHouseMenu;
Menu dinerMenu;
Menu cafeMenu;
/**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
/**
* 新增一个cafeMenu
* @param pancakeHouseMenu
* @param dinerMenu
* @param cafeMenu
*/
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
this.cafeMenu = cafeMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
Iterator cafeIterator = cafeMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
System.out.println("\nDINNER");
printMenu(cafeIterator);
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
Test
[java] view
plaincopyprint?
package dinermerger;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
// PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
// DinerMenu dinerMenu = new DinerMenu();
//
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
//
// waitress.printMenu();
Menu pancakeHouseMenu = new PancakeHouseMenu();
Menu dinerMenu = new DinerMenu();
Menu cafeMenu = new CafeMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu, cafeMenu);
waitress.printMenu();
}
}
结果：
MENU
----
BREAKFAST
K&B's Pancake Breakfast, 2.99 -- Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast, 2.99 -- Pancakes with fried eggs, sausage
Blueberry Pancakes, 3.49 -- Pancakes made with fresh blueberries
Waffles, 3.59 -- Waffles, with your choice of blueberries or strawberries
LUNCH
Vegetarian BLT, 2.99 -- (Fakin') Bacon with lettuce & tomato on Whole wheat
BLT, 2.99 -- Bacon with lettuce & tomato on Whole wheat
Soup of the day, 3.29 -- Soup of the day, with a side of potato salad
Hotdog, 3.05 -- A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice, 3.99 -- Steamed vegetables over brown rice
Pasta, 3.89 -- Spaghetti with Marinara Sauce, and a slice of sourdough bread
DINNER
Soup of the day, 3.69 -- A cup of the soup of the day, with a side salad
Burrito, 4.29 -- A large burrito, with whole pinto beans, salsa, guacamole
Veggie Burger and Air Fries, 3.99 -- Veggie burger on a whole wheat bun, lettuce, tomato, and fries
为了让女招待更加有扩展性，我们这样做
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 女招待类
* @author wwj
*
*/
public class Waitress {
// PancakeHouseMenu pancakeHouseMenu;
// DinerMenu dinerMenu;
// Menu pancakeHouseMenu;
// Menu dinerMenu;
// Menu cafeMenu;
ArrayList menus;
/* *//**
*在这个构造器中，女招待照顾两个菜单
* @param pancakeHouseMenu
* @param dinerMenu
*//*
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
*//**
* 新增一个cafeMenu
* @param pancakeHouseMenu
* @param dinerMenu
* @param cafeMenu
*//*
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
this.cafeMenu = cafeMenu;
}*/
public Waitress(ArrayList menus) {
this.menus = menus;
}
public void printMenu() {
/* Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
Iterator cafeIterator = cafeMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
System.out.println("\nDINNER");
printMenu(cafeIterator);*/
Iterator menuIterator = menus.iterator();
while(menuIterator.hasNext()) {
Menu menu = (Menu)menuIterator.next();
printMenu(menu.createIterator());
}
}
private void printMenu(Iterator iterator) {
while(iterator.hasNext()) { //测试是否还有其他项
MenuItem menuItem = (MenuItem) iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
}
测试的时候我们就可以这样
[java] view
plaincopyprint?
package dinermerger;
import java.util.ArrayList;
public class MenuTestDrive {
/**
* @param args
*/
public static void main(String[] args) {
// PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
// DinerMenu dinerMenu = new DinerMenu();
//
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
//
// waitress.printMenu();
Menu pancakeHouseMenu = new PancakeHouseMenu();
Menu dinerMenu = new DinerMenu();
Menu cafeMenu = new CafeMenu();
// Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu, cafeMenu);
ArrayList menus = new ArrayList();
menus.add(pancakeHouseMenu);
menus.add(dinerMenu);
menus.add(cafeMenu);
Waitress waitress = new Waitress(menus);
waitress.printMenu();
}
}
总算是要讲到组合模式了，这个模式可以解决迭代器模式中不能解决的一个难题。比如我们需要一个新的餐单，菜单下又有子菜单，单单用迭代器就不能解决了。这时候可以考虑到用树形结构来展示整个菜单。
看下面的例子吧：
定义菜单组件
[java] view
plaincopyprint?
package composite;
/**
* 定义菜单组件
* @author Administrator
*
*/
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();
}
}
实现菜单
[java] view
plaincopyprint?
package composite;
import java.util.ArrayList;
import java.util.Iterator;
public class Menu extends MenuComponent{
ArrayList menuComponents = new ArrayList();
String name;
String description;
public Menu(String name, String description) {
this.name = name;
this.description = description;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return (MenuComponent) menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public void print(){
System.out.print("\n" + getName());
System.out.println(", " + getDescription());
System.out.println("------------------");
Iterator iterator = menuComponents.iterator();
while(iterator.hasNext()) {
MenuComponent menuComponent =
(MenuComponent) iterator.next();
menuComponent.print();
}
}
}
实现菜单项
[java] view
plaincopyprint?
package composite;
/**
* 实现菜单项
* @author Administrator
*
*/
public class MenuItem extends MenuComponent{
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 void print(){
System.out.print(" " + getName());
if(isVegetarian()) {
System.out.print("(v)");
}
System.out.println("," + getPrice());
System.out.println(" --" + getDescription());
}
}
变得十分快乐的女招待
[java] view
plaincopyprint?
package composite;
import java.util.Iterator;
public class Waitress {
MenuComponent allMenus;
public Waitress(MenuComponent allMenus) {
this.allMenus = allMenus;
}
public void printMenu() {
allMenus.print();
}
}
我们这样测试
[java] view
plaincopyprint?
package composite;
import java.util.*;
public class MenuTestDrive {
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 dessertMenu =
new Menu("DESSERT MENU", "Dessert of course!");
MenuComponent coffeeMenu = new Menu("COFFEE MENU", "Stuff to go with your afternoon coffee");
MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");
allMenus.add(pancakeHouseMenu);
allMenus.add(dinerMenu);
allMenus.add(cafeMenu);
pancakeHouseMenu.add(new MenuItem(
"K&B's Pancake Breakfast",
"Pancakes with scrambled eggs, and toast",
true,
2.99));
pancakeHouseMenu.add(new MenuItem(
"Regular Pancake Breakfast",
"Pancakes with fried eggs, sausage",
false,
2.99));
pancakeHouseMenu.add(new MenuItem(
"Blueberry Pancakes",
"Pancakes made with fresh blueberries, and blueberry syrup",
true,
3.49));
pancakeHouseMenu.add(new MenuItem(
"Waffles",
"Waffles, with your choice of blueberries or strawberries",
true,
3.59));
dinerMenu.add(new MenuItem(
"Vegetarian BLT",
"(Fakin') Bacon with lettuce & tomato on whole wheat",
true,
2.99));
dinerMenu.add(new MenuItem(
"BLT",
"Bacon with lettuce & tomato on whole wheat",
false,
2.99));
dinerMenu.add(new MenuItem(
"Soup of the day",
"A bowl of the soup of the day, with a side of potato salad",
false,
3.29));
dinerMenu.add(new MenuItem(
"Hotdog",
"A hot dog, with saurkraut, relish, onions, topped with cheese",
false,
3.05));
dinerMenu.add(new MenuItem(
"Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice",
true,
3.99));
dinerMenu.add(new MenuItem(
"Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true,
3.89));
dinerMenu.add(dessertMenu);
dessertMenu.add(new MenuItem(
"Apple Pie",
"Apple pie with a flakey crust, topped with vanilla icecream",
true,
1.59));
dessertMenu.add(new MenuItem(
"Cheesecake",
"Creamy New York cheesecake, with a chocolate graham crust",
true,
1.99));
dessertMenu.add(new MenuItem(
"Sorbet",
"A scoop of raspberry and a scoop of lime",
true,
1.89));
cafeMenu.add(new MenuItem(
"Veggie Burger and Air Fries",
"Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
true,
3.99));
cafeMenu.add(new MenuItem(
"Soup of the day",
"A cup of the soup of the day, with a side salad",
false,
3.69));
cafeMenu.add(new MenuItem(
"Burrito",
"A large burrito, with whole pinto beans, salsa, guacamole",
true,
4.29));
cafeMenu.add(coffeeMenu);
coffeeMenu.add(new MenuItem(
"Coffee Cake",
"Crumbly cake topped with cinnamon and walnuts",
true,
1.59));
coffeeMenu.add(new MenuItem(
"Bagel",
"Flavors include sesame, poppyseed, cinnamon raisin, pumpkin",
false,
0.69));
coffeeMenu.add(new MenuItem(
"Biscotti",
"Three almond or hazelnut biscotti cookies",
true,
0.89));
Waitress waitress = new Waitress(allMenus);
waitress.printMenu();
}
}
测试结果：
ALL MENUS, All menus combined
------------------
PANCAKE HOUSE MENU, Breakfast
------------------
K&B's Pancake Breakfast(v),2.99
--Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast,2.99
--Pancakes with fried eggs, sausage
Blueberry Pancakes(v),3.49
--Pancakes made with fresh blueberries, and blueberry syrup
Waffles(v),3.59
--Waffles, with your choice of blueberries or strawberries
DINER MENU, Lunch
------------------
Vegetarian BLT(v),2.99
--(Fakin') Bacon with lettuce & tomato on whole wheat
BLT,2.99
--Bacon with lettuce & tomato on whole wheat
Soup of the day,3.29
--A bowl of the soup of the day, with a side of potato salad
Hotdog,3.05
--A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice(v),3.99
--Steamed vegetables over brown rice
Pasta(v),3.89
--Spaghetti with Marinara Sauce, and a slice of sourdough bread
DESSERT MENU, Dessert of course!
------------------
Apple Pie(v),1.59
--Apple pie with a flakey crust, topped with vanilla icecream
Cheesecake(v),1.99
--Creamy New York cheesecake, with a chocolate graham crust
Sorbet(v),1.89
--A scoop of raspberry and a scoop of lime
CAFE MENU, Dinner
------------------
Veggie Burger and Air Fries(v),3.99
--Veggie burger on a whole wheat bun, lettuce, tomato, and fries
Soup of the day,3.69
--A cup of the soup of the day, with a side salad
Burrito(v),4.29
--A large burrito, with whole pinto beans, salsa, guacamole
COFFEE MENU, Stuff to go with your afternoon coffee
------------------
Coffee Cake(v),1.59
--Crumbly cake topped with cinnamon and walnuts
Bagel,0.69
--Flavors include sesame, poppyseed, cinnamon raisin, pumpkin
Biscotti(v),0.89
--Three almond or hazelnut biscotti cookies
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 设计模式学习--迭代器模式(Iterator Pattern)和组合模式（Composite Pattern)
- 设计模式学习--迭代器模式(Iterator Pattern)和组合模式（Composite Pattern)
- 设计模式学习总结-迭代器模式（Iterator Pattern）
- 设计模式学习笔记---迭代器模式iterator pattern（Java版）
- 设计模式学习总结-迭代器模式（Iterator Pattern）
- c++设计模式：迭代器模式(Iterator Pattern)
- 十一个行为型模式4：迭代器模式-Iterator Pattern【学习难度：★★★☆☆，使用频率：★★★★★】
- 步步为营 .NET 设计模式学习笔记 十一、Iterator(迭代器模式)
- 极速理解设计模式系列：16.迭代器模式(Iterator Pattern)
- Net设计模式实例之迭代器模式（Iterator Pattern）（2） 推荐
- Design Pattern学习笔记之迭代器模式和复合模式（the Iterator and Composite Pattern）
- Java设计模式--迭代器模式【Iterator Pattern】
- .NET设计模式（18）：迭代器模式（Iterator Pattern）
- 设计模式C++学习笔记之十四（Iterator迭代器模式）
- 我所理解的设计模式（C++实现）——迭代器模式（Iterator Pattern）
- 迭代器模式 Iterator，组合模式 Composite -- 学习HeadFirst设计模式记录
- .NET设计模式（18）：迭代器模式（Iterator Pattern）
- java_设计模式_迭代器模式_Iterator Pattern（2016-08-12）
- 设计模式之九：迭代器模式（Iterator Pattern）
- 设计模式C++学习笔记之十四（Iterator迭代器模式）