迭代器模式
场景描述：我们目前正在吞并期，刚把一个煎饼店和一个餐厅兼并了。但是关于菜单的设计上好像遇到了写麻烦，两者采用的集合不同，一个用数组，一个用ArrayList。
尝试：如果我们想要打印菜单，就需要分别对两种不同的集合进行处理。
我们可以封装遍历吗？不论是那种集合，我们都可以统一进行处理。
这就需要引出迭代器了。
public interface Iterator {
boolean hasNext();
Object next();
}
以及我们的菜单项格式
public class MenuItem {
public String name;
public String description;
public boolean vegetarian;
public 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;
}
}
然后我们分别为不同的菜单设计不同的迭代器：
餐厅的
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);
}
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 DinerMenuIterator implements Iterator {
MenuItem[] items;
int position = 0;
public DinerMenuIterator(MenuItem[] items){
this.items = items;
}
public Object next(){
MenuItem menuItem = items[position];
position += 1;
return menuItem;
}
@Override
public boolean hasNext() {
if (position >= items.length || items[position] == null) {
return false;
}else {
return true;
}
}
}
煎饼店的
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 createIterator(){
return new PancakeIterator(menuItems);
}
}
public class PancakeIterator implements Iterator {
ArrayList menuItems;
int position = 0;
public PancakeIterator(ArrayList menuItems){
this.menuItems = menuItems;
}
public Object next(){
MenuItem menuItem =(MenuItem) menuItems.get(position);
position += 1;
return menuItem;
}
@Override
public boolean hasNext() {
if (position >= menuItems.size()){
return false;
}else {
return true;
}
}
}
这样我们新建一个服务员，她就可以开始报菜名啦！
public class Waitress {
PancakeHouseMenu pancakeHouseMenu;
DinerMenu 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);
}
public 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());
}
}
}
测试一下
public class MenuTestDrive {
public static void main(String[] args) {
PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
DinerMenu dinerMenu = new DinerMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
waitress.printMenu();
}
}
我们看一下我们的实现关系图
当然，java本身就提供了迭代器接口java.util.Iterator
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。
这个模式给你提供了一种方法，可以顺序访问一个聚集对象中的元素，而又不用知道内部是如何表示的。
如果你有一个统一的方法访问聚合中的每一个对象，你就可以编写多态的代码和这些聚合搭配。另一个对你设计造成重要影响的，是迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象。
我们看一下该模式的类图
迭代器意味着没有次序。只是取出所有的元素，并不表示取出元素的先后就代表元素的大小次序。除非某个集合的文件有特别说明，否则不可以对迭代器所取出的元素大小顺序作出假设。
外部迭代器，就是客户通过调用next()取得下一个元素。迭代器的操作由客户控制。
内部迭代器，是由迭代器自己控制。在这种情况下，因为是由迭代器自行在元素之间游走，所以你必须告诉迭代器在游走过程中要做些什么事，也就是说，你必须将操作传入给迭代器。
组合模式
设计原则：一个类应该只有一个引起变化的原因。
类的每个责任都由改变的潜在区域。超过一个责任，意味着超过一个改变的区域。
内聚（cohesion），它用来度量一个类或模块紧密地达到单一目的或责任。
当一个模块或一个个类被设计成只支持一组相关的功能时，我们说它具有高内聚；反之，当被设计成支持一组不相关的功能时，我们说它具有低内聚。
新的需求：我们的兼并之路并没有停止，我们又兼并了一个咖啡馆，这样我们可以按照之前的操作方法将它的菜单也统一管理起来。但是我们在新增咖啡馆的菜单时，要修改服务员的代码，并且相同的打印方法调用了多次；更严重的问题是，我们的餐厅菜单下有了一个甜点的子菜单。
听起来好麻烦啊，我们用图的形式来表述吧。
我们更加形象化一点，就可以得到一个树形结构
组合模式允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。
组合包含组件。组件有两种：组合与叶节点元素。
我们看一下类图
该模式是如何解决我们的问题？
那么让我们尝试着解决现有问题吧
首先我们需要构建菜单组件
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();
}
public abstract Iterator createIterator();
}
然后实现具体组合和叶节点
菜单相当于组合
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);
}
@Override
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
@Override
public MenuComponent getChild(int i) {
return (MenuComponent)menuComponents.get(i);
}
@Override
public String getName() {
return name;
}
@Override
public String getDescription() {
return description;
}
@Override
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();
}
}
public Iterator createIterator(){
return new CompositeIterator(menuComponents.iterator());
}
}
菜单子项相当于叶节点
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;
}
@Override
public double getPrice() {
return price;
}
@Override
public boolean isVegetarian() {
return vegetarian;
}
public void print(){
System.out.print(" " + getName());
if (isVegetarian()){
System.out.print("(v)");
}
System.out.println("," + getPrice());
System.out.println(" -- " + getDescription());
}
public Iterator createIterator(){
return new NullIterator();
}
}
然后我们实现一个服务员的代码
public class Waitress {
MenuComponent allMenus;
public Waitress(MenuComponent allMenus){
this.allMenus = allMenus;
}
public void printMenu(){
allMenus.print();
}
public void printVegetarianMenu(){
Iterator iterator = allMenus.createIterator();
System.out.println("\nVEGETARIAN MENU\n-----");
while (iterator.hasNext()){
MenuComponent menuComponent = (MenuComponent)iterator.next();
try {
if (menuComponent.isVegetarian()){
menuComponent.print();
}
}catch (UnsupportedOperationException e){}
}
}
}
因为我们需要寻找出菜单中的所有素食项，因此需要操作这棵树的所有节点，并进行遍历。这个时候就需要用到迭代器了。
我们实现一个组合迭代器
public class CompositeIterator implements Iterator {
Stack stack = new Stack();
public CompositeIterator(Iterator iterator){
stack.push(iterator);
}
public Object next(){
if (hasNext()){
// 注意这里取的是栈的最上层迭代器，所以如果一个迭代器下还有迭代器的时候，优先取下层迭代器的值，然后再回到上层。
// 这才是递归的关键所在。
Iterator iterator = (Iterator) stack.peek();
MenuComponent component = (MenuComponent) iterator.next();
if (component instanceof Menu){
stack.push(component.createIterator());
}
return component;
}else {
return null;
}
}
@Override
public boolean hasNext() {
if (stack.isEmpty()){
return false;
}else {
Iterator iterator = (Iterator) stack.peek();
if (!iterator.hasNext()){
stack.pop();
return hasNext();
}else {
return true;
}
}
}
public void remove(){
throw new UnsupportedOperationException();
}
}
一个空的迭代器
public class NullIterator implements Iterator {
public Object next(){
return null;
}
@Override
public boolean hasNext() {
return false;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
最后测试一下
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 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", 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("Blueberry Pancakes", "Pancakes made with fresh blueberries", true, 3.49));
dinerMenu.add(new MenuItem("Waffles", "Waffles, with your choice of blueberries or strawberries", true, 3.59));
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 ice cream", true, 1.59));
dessertMenu.add(new MenuItem("Cheesecake", "Creamy New York cheesecake, with a chocolate graham crust", true, 1.99));
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));
Waitress waitress = new Waitress(allMenus);
// waitress.printMenu();
waitress.printVegetarianMenu();
}
}
查看一下结果是否是我们想要的
组合模式以单一责任设计原则换取透明性。什么是透明性？通过让组件的接口同时包含一些管理子节点和叶节点的操作，客户就可以将组合和叶节点一视同仁。也就是说，一个元素究竟是组合还是叶节点，对客户是透明的。
在应用组合模式时，如果你有一个需要保持特定孩子次序的组合对象，就需要使用复杂的管理方案来进行孩子的增加和删除（比如我们可以通过栈来做缓存），而且当你在这个层次结构内游走时，应该要更加小心。
总结：我们在使用不同集合，但又需要统一管理这些集合的时候，就需要使用迭代器模式了，而且迭代器的实现还可以避免一些错误（关于remove操作导致的计数器问题）。
而当我们需要实现一种树形结构进行管理的时候，就要立即想到组合模式了。文件管理系统就是最常见的树形结构。
扫一扫
586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
