标签：lock imp i++ 方法 aggregate 之一 pac 比较 定义
一、迭代器模式简介
Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
二、迭代器模式的角色与职责
Iterator（迭代器接口）：该接口必须定义实现迭代功能的最小定义方法集比如提供hasNext()和next()方法。
ConcreteIterator（迭代器实现类）：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
Aggregate（容器接口）：定义基本功能以及提供类似Iterator iterator()的方法。
concreteAggregate（容器实现类）：容器接口的实现类。必须实现Iterator iterator()方法。
三、迭代器模式的具体实现
有一个餐厅和煎饼屋要合并，但是每个老板都只想用自己的菜单模式，餐厅使用的是数组形式的菜单，而煎饼屋使用的是ArrayList形式。
虽然实现形式不太一样，但是每个菜单项的内容是一样的，我们看一下菜单项的设计，比较常规的列出了名称、描述、是否是素食、价格：
// An highlighted block
package design.iterator.gys.noiterator;
public class MenuItem {
String name;
String desc;
boolean vegetarian;
double price;
public MenuItem(String name, String desc, boolean vegetarian, double price) {
super();
this.name = name;
this.desc = desc;
this.vegetarian = vegetarian;
this.price = price;
}
public String getName() {
return name;
}
public String getDesc() {
return desc;
}
public boolean isVegetarian() {
return vegetarian;
}
public double getPrice() {
return price;
}
}
1、不使用迭代器模式
一开始老板们各执己见，不愿意更改自己的菜单，那我们就瞧一眼两个菜单吧。
餐厅：
// An highlighted block
package design.iterator.gys.noiterator;
public class DinnerMenu {
static final int Max=6;
int numberOfItem=0;
MenuItem[] menu;
public DinnerMenu() {
menu=new MenuItem[Max];
addItem("a2","b2",true,6.99);
addItem("c2","d2",false,7.99);
addItem("e2","f2",true,8.99);
addItem("g2","h2",false,9.99);
}
public void addItem(String name,String desc,boolean vegetarian,double price){
MenuItem mt=new MenuItem(name, desc, vegetarian, price);
if(numberOfItem>=Max)
System.out.println("menu is full");
else
{
menu[numberOfItem]=mt;
numberOfItem++;
}
}
public MenuItem[] getMenu() {
return menu;
}
}
煎饼屋：
// An highlighted block
package design.iterator.gys.noiterator;
import java.util.ArrayList;
public class PancakeHouseMenu {
ArrayList menu;
public PancakeHouseMenu() {
menu=new ArrayList();
addItem("a1","b1",true,1.99);
addItem("c1","d1",false,2.99);
addItem("e1","f1",true,3.99);
addItem("g1","h1",false,4.99);
}
public void addItem(String name,String desc,boolean vegetarian,double price){
MenuItem mt=new MenuItem(name, desc, vegetarian, price);
menu.add(mt);
}
public ArrayList getMenu() {
return menu;
}
}
果然风格迥异啊，这下可忙坏了服务员，得区分开两个菜单，不然一不小心可就要出洋相了。首先要取得菜单的形式，还都不一样，服务员需要对两者分别进行迭代：
// An highlighted block
package design.iterator.gys.noiterator;
import java.util.ArrayList;
public class Waitress {
private PancakeHouseMenu menu1;
private DinnerMenu menu2;
public Waitress(PancakeHouseMenu menu1, DinnerMenu menu2) {
super();
this.menu1 = menu1;
this.menu2 = menu2;
}
public void printMenu()
{
ArrayList breakfastMenu=menu1.getMenu();
MenuItem[] lunchMenu=menu2.getMenu();
System.out.println("***PancakeHouseMenu***");
for(int i=0;i<breakfastMenu.size();i++)
{
MenuItem mt=(MenuItem)breakfastMenu.get(i);
System.out.println(mt.getName()+" "+mt.getDesc()+" "+mt.getPrice());
}
System.out.println("***DinnerMenu***");
for(int i=0;i<lunchMenu.length && lunchMenu[i]!=null;i++)
{
MenuItem mt=lunchMenu[i];
System.out.println(mt.getName()+" "+mt.getDesc()+" "+mt.getPrice());
}
}
}
看看餐厅的运行情况：
// An highlighted block
package design.iterator.gys.noiterator;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
PancakeHouseMenu m=new PancakeHouseMenu();
DinnerMenu d=new DinnerMenu();
Waitress w=new Waitress(m, d);
w.printMenu();
}
}
// An highlighted block
***PancakeHouseMenu***
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
***DinnerMenu***
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
很好，没出什么大的问题，服务员可算是尽心尽职的了。
那么问题来了，服务员需要两个循环来遍历外汇返佣菜单项，并且服务员和具体的菜单捆绑在一起，无法进行更多的功能扩展，并且两个菜单的内部实现完全暴露给了服务员，虽然我们不愿觉得他是坏人，但是万一呢。
2、使用迭代器模式
方案设计
类设计
为了减轻服务员的工作，让她只熟悉一个接口就能将所有的菜单打印出来。
首先我们对迭代器类进行抽象，但是仍然将菜单的内容留给厨师进行更改，并且在这里我们使用的是自定义的迭代器形式。
// An highlighted block
package design.iterator.gys.iterator;
public interface Iterator {
public boolean hasNext();
public Object next();
}
下面是餐厅迭代器的实现，由于菜单是数组类型，我们使用数组下标进行设计，由于是固定长度的数组，我们不仅要判断索引是否超过也要判断数组的内容是否为空：
// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class DinnerMenuIterator implements Iterator{
private MenuItem[] menu;
private int start=0;
public DinnerMenuIterator(MenuItem[] menu) {
super();
this.menu = menu;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if(start<menu.length&&menu[start]!=null)
return true;
else
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
return menu[start++];
}
}
煎饼屋的菜单使用ArrlyList实现的，属于可变长度：
// An highlighted block
package design.iterator.gys.iterator;
import java.util.ArrayList;
public class PancakeHouseMenuIterator implements Iterator{
private ArrayList menu;
private int start=0;
public PancakeHouseMenuIterator(ArrayList menu) {
super();
this.menu = menu;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if(start<menu.size())
return true;
else
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
return menu.get(start++);
}
}
至此，我们实现了两个菜单的迭代器。那么接下来我们就要在菜单内部进行处理，以便让服务员获得这个迭代器。
餐厅：
// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class DinnerMenu {
static final int Max=6;
int numberOfItem=0;
MenuItem[] menu;
public DinnerMenu() {
menu=new MenuItem[Max];
addItem("a2","b2",true,6.99);
addItem("c2","d2",false,7.99);
addItem("e2","f2",true,8.99);
addItem("g2","h2",false,9.99);
}
public void addItem(String name,String desc,boolean vegetarian,double price){
MenuItem mt=new MenuItem(name, desc, vegetarian, price);
if(numberOfItem>=Max)
System.out.println("menu is full");
else
{
menu[numberOfItem]=mt;
numberOfItem++;
}
}
public Iterator createIterator() {
return new DinnerMenuIterator(menu);
}
}
煎饼屋：
// An highlighted block
package design.iterator.gys.iterator;
import java.util.ArrayList;
import design.iterator.gys.noiterator.MenuItem;
public class PancakeHouseMenu {
ArrayList menu;
public PancakeHouseMenu() {
menu=new ArrayList();
addItem("a1","b1",true,1.99);
addItem("c1","d1",false,2.99);
addItem("e1","f1",true,3.99);
addItem("g1","h1",false,4.99);
}
public void addItem(String name,String desc,boolean vegetarian,double price){
MenuItem mt=new MenuItem(name, desc, vegetarian, price);
menu.add(mt);
}
public Iterator createIterator() {
return new PancakeHouseMenuIterator(menu);
}
}
看看新来的服务员适应如何:
// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class Waitress {
PancakeHouseMenu menu1;
DinnerMenu memu2;
public Waitress(PancakeHouseMenu menu1, DinnerMenu memu2) {
super();
this.menu1 = menu1;
this.memu2 = memu2;
}
public void printMenu() {
Iterator i1=menu1.createIterator();
printMenu(i1);
System.out.println("----------");
Iterator i2=memu2.createIterator();
printMenu(i2);
}
public void printMenu(Iterator iterator)
{
while(iterator.hasNext()) {
MenuItem m=(MenuItem)iterator.next();
System.out.println(m.getName()+" "+m.getDesc()+" "+m.getPrice());
}
}
}
So easy!现在服务员只需要调用每个菜单的迭代器，就能实现对菜单的遍历，不用再去了解内部的实现机制了。
// An highlighted block
package design.iterator.gys.iterator;
public class Tset {
public static void main(String[] args) {
// TODO Auto-generated method stub
PancakeHouseMenu p=new PancakeHouseMenu();
DinnerMenu d=new DinnerMenu();
Waitress w=new Waitress(p, d);
w.printMenu();
System.out.println("**********");
Iterator i=d.createIterator();
w.printMenu(i);
}
}
测试结果：
// An highlighted block
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
----------
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
**********
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
效果不错，并且能单独对一个菜单进行输出了。
————————————————
原文链接：https://blog.csdn.net/qq_22118991/article/details/84968047
标签：lock imp i++ 方法 aggregate 之一 pac 比较 定义
原文地址：https://www.cnblogs.com/benming/p/11725502.html
