设计模式之迭代器模式
1. 什么是迭代器模式
Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。
在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用
Iterator模式，会存在什么问题：
-
由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法
-
让调用者自己实现遍历。直接暴露数据细节给外部。
以上方法1与方法2都可以实现对遍历，这样有问题呢？
-
容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。
-
往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。
迭代器模式的一般应用：
Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。
所以，Iterator模式的应用场景可以归纳为满足以下几个条件：
- 访问容器中包含的内部对象
- 按顺序访问
迭代器模式的结构：
- Iterator（迭代器接口）：该接口必须定义实现迭代功能的最小定义方法集比如提供hasNext()和next()方法。这是所有的迭代器必须要实现的方法，可以使用java内置的Iterator也可以自己个性化定制
- ConcreteIterator（迭代器实现类）：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
- Aggregate（容器接口）：定义基本功能以及提供类似Iterator iterator()的方法；
- concreteAggregate（容器实现类）：容器接口的实现类。必须实现Iterator iterator()方法。
优点：
-
实现功能分离，简化容器接口。让容器只实现本身的基本功能，把迭代功能委让给外部类实现，符合类的设计原则。
-
隐藏容器的实现细节。
-
为容器或其子容器提供了一个统一接口，一方面方便调用；另一方面使得调用者不必关注迭代器的实现细节。
-
可以为容器或其子容器实现不同的迭代方法或多个迭代方法。
2.1具体实例
举一个具体的例子吧，xain’z现在有两家餐厅要合并，合并之后呢需要把菜单统一合并，形成一个统一的菜单，在打印的时候呢能够全部打印出来。
首先的设计想法呢就是每一个餐厅设计一个自己的菜单的类，但是自己在设计的时候使用的是不同的数据结构实现的这个菜单类，这样子的话其实在写一个专门的类似于打印的类，然后实例化两个餐厅然后打印出来。这样的话就是我要再合并一个餐厅的时候需要更改这个类。比较麻烦，所以我们就需要使用迭代器模式来设计这个项目。使用迭代器的话就很容易解耦餐厅和打印菜单之间的耦合关系。具体是怎么实现呢？
首先需要实现一个迭代器的接口：
public interface Iterator {
public boolean hasNext();
public Object next();
}
然后具体的类去扩展实现它：
ublic class DinerMenu {
private final static int Max_Items = 5;
private int numberOfItems = 0;
private MenuItem[] menuItems;
public DinerMenu() {
menuItems = new MenuItem[Max_Items];
addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
addItem("bean soup", "bean&potato salad", true, 3.28f);
addItem("hotdog", "onions&cheese&bread", false, 3.05f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
if (numberOfItems >= Max_Items) {
System.err.println("sorry,menu is full!can not add another item");
} else {
menuItems[numberOfItems] = menuItem;
numberOfItems++;
}
}
public Iterator getIterator() {
return new DinerIterator();
}
class DinerIterator implements Iterator {
private int position;
public DinerIterator() {
position = 0;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if (position < numberOfItems) {
return true;
}
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
MenuItem menuItem = menuItems[position];
position++;
return menuItem;
}
}
}
public class CakeHouseMenu {
private ArrayList<MenuItem> menuItems;
public CakeHouseMenu() {
menuItems = new ArrayList<MenuItem>();
addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
addItem("Stawberry Cake","fresh stawberry",true,3.29f);
addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
menuItems.add(menuItem);
}
public Iterator getIterator()
{
return new CakeHouseIterator() ;
}
class CakeHouseIterator implements Iterator
{
private int position=0;
public CakeHouseIterator()
{
position=0;
}
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if(position<menuItems.size())
{
return true;
}
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
MenuItem menuItem =menuItems.get(position);
position++;
return menuItem;
}};
//其他功能代码
}
最后就是具体的合并之后的打印类：
public class Waitress {
private ArrayList<Iterator> iterators=new ArrayList<Iterator>();
public Waitress() {
}
public void addIterator(Iterator iterator)
{
iterators.add(iterator);
}
public void printMenu() {
Iterator iterator;
MenuItem menuItem;
for (int i = 0, len = iterators.size(); i < len; i++) {
iterator = iterators.get(i);
while(iterator.hasNext())
{
menuItem=(MenuItem) iterator.next();
System.out.println(menuItem.getName() + "***"
+menuItem.getPrice()+"***"+ menuItem.getDescription());
}
}
}
public void printBreakfastMenu() {
}
public void printLunchMenu() {
}
public void printVegetableMenu() {
}
}
测试类：
public class MainTest {
public static void main(String[] args) {
Waitress mWaitress=new Waitress();
CakeHouseMenu mCakeHouseMenu = new CakeHouseMenu();
DinerMenu mDinerMenu = new DinerMenu();
mWaitress.addIterator(mCakeHouseMenu.getIterator());
mWaitress.addIterator(mDinerMenu.getIterator());
mWaitress.printMenu();
}
}
上面的方式其实是我们自己写了一个迭代器，其实java有内置的迭代器，我们用过collection的就知道，遍历的时候就是使用的Iterator。
上面的扩展实现Iterator的类使用java内置的Iterator怎么来做呢？
首先是： DinerMenu，因为他的菜单是数组实现的，没有内置的迭代器，所以还是需要我们自己继承内置的迭代器然后自己扩展实现一个。
public class DinerMenu {
private final static int Max_Items = 5;
private int numberOfItems = 0;
private MenuItem[] menuItems;
public DinerMenu() {
menuItems = new MenuItem[Max_Items];
addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
addItem("bean soup", "bean&potato salad", true, 3.28f);
addItem("hotdog", "onions&cheese&bread", false, 3.05f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
if (numberOfItems >= Max_Items) {
System.err.println("sorry,menu is full!can not add another item");
} else {
menuItems[numberOfItems] = menuItem;
numberOfItems++;
}
}
public Iterator getIterator() {
return new DinerIterator();
}
class DinerIterator implements Iterator {
private int position = 0;
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
if (position < numberOfItems) {
return true;
}
position = 0;
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
MenuItem menuItem = menuItems[position];
position++;
return menuItem;
}
@Override
public void remove() {
// TODO Auto-generated method stub
}
}
}
CakeHouseMenu的菜单是由 ArrayList，java内的 ArrayList是有Iterator的直接使用就可以了。
public class CakeHouseMenu {
private ArrayList<MenuItem> menuItems;
private int position=0;
public CakeHouseMenu() {
menuItems = new ArrayList<MenuItem>();
addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
addItem("Stawberry Cake","fresh stawberry",true,3.29f);
addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
}
private void addItem(String name, String description, boolean vegetable,
float price) {
MenuItem menuItem = new MenuItem(name, description, vegetable, price);
menuItems.add(menuItem);
}
public Iterator getIterator()
{
return menuItems.iterator();
}
//其他功能代码
}
看了上面的迭代器，之后next方法，那我要是访问前一个的时候怎么办，有没有previous的方法，当你自己个性化实现迭代器的时候是可以实现的，你添加两个方法，一个是获取前一个元素，一个是告诉你是否到达了最前面。然后Java的Collection FrameWork提供了另一种迭代器接口ListIterator,这个接口里面就是那个previous的方法，可以访问前一个元素。
3. 单一责任原则
单一责任原则就是：一个类应该只有一个引起变化的原因。
实现单一责任原则的话，在维护和修改代码的时候更加容易，因为每一个类只承担了一种责任，修改的该类的区域可能也就只有一组，但是很多种责任聚合在一块儿的话就修改的区域就会很多，并且你会感觉自己改的是乱起八糟的。
内聚是一个比单一责任原则更加普遍的概念，它用来度量一个类或模块紧密地达到单一目的或责任。当一个模块被设计的只支持一组相关功能的时候就是高内聚的，当被设计成支持一组不相关的功能的时候就是低内聚的。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
