遍历聚合对象中的元素——迭代器模式（三）

来源：互联网发布：淘宝联盟频道推广编辑：程序博客网时间：2024/05/01 03:52

遍历聚合对象中的元素——迭代器模式（三）

3 完整解决方案

为了简化AbstractObjectList类的结构，并给不同的具体数据集合类提供不同的遍历方式，Sunny软件公司开发人员使用迭代器模式来重构AbstractObjectList类的设计，重构之后的销售管理系统数据遍历结构如图4所示：

图4 销售管理系统数据遍历结构图

（注：为了简化类图和代码，本结构图中只提供一个具体聚合类和具体迭代器类）

在图4中，AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。完整代码如下所示：

[java] view plaincopy
//在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历  
import java.util.*;  
  
//抽象聚合类  
abstract class AbstractObjectList {  
    protected List<Object> objects = new ArrayList<Object>();  
  
    public AbstractObjectList(List objects) {  
        this.objects = objects;  
    }  
      
    public void addObject(Object obj) {  
        this.objects.add(obj);  
    }  
      
    public void removeObject(Object obj) {  
        this.objects.remove(obj);  
    }  
      
    public List getObjects() {  
        return this.objects;  
    }  
      
    //声明创建迭代器对象的抽象工厂方法  
    public abstract AbstractIterator createIterator();  
}  
  
//商品数据类：具体聚合类  
class ProductList extends AbstractObjectList {  
    public ProductList(List products) {  
        super(products);  
    }  
      
    //实现创建迭代器对象的具体工厂方法  
    public AbstractIterator createIterator() {  
        return new ProductIterator(this);  
    }  
}   
  
//抽象迭代器  
interface AbstractIterator {  
    public void next(); //移至下一个元素  
    public boolean isLast(); //判断是否为最后一个元素  
    public void previous(); //移至上一个元素  
    public boolean isFirst(); //判断是否为第一个元素  
    public Object getNextItem(); //获取下一个元素  
    public Object getPreviousItem(); //获取上一个元素  
}  
  
//商品迭代器：具体迭代器  
class ProductIterator implements AbstractIterator {  
    private ProductList productList;  
    private List products;  
    private int cursor1; //定义一个游标，用于记录正向遍历的位置  
    private int cursor2; //定义一个游标，用于记录逆向遍历的位置  
      
    public ProductIterator(ProductList list) {  
        this.productList = list;  
        this.products = list.getObjects(); //获取集合对象  
        cursor1 = 0; //设置正向遍历游标的初始值  
        cursor2 = products.size() -1; //设置逆向遍历游标的初始值  
    }  
      
    public void next() {  
        if(cursor1 < products.size()) {  
            cursor1++;  
        }  
    }  
      
    public boolean isLast() {  
        return (cursor1 == products.size());  
    }  
      
    public void previous() {  
        if (cursor2 > -1) {  
            cursor2--;  
        }  
    }  
      
    public boolean isFirst() {  
        return (cursor2 == -1);  
    }  
      
    public Object getNextItem() {  
        return products.get(cursor1);  
    }   
          
    public Object getPreviousItem() {  
        return products.get(cursor2);  
    }     
}  

编写如下客户端测试代码：

[java] view plaincopy
class Client {  
    public static void main(String args[]) {  
        List products = new ArrayList();  
        products.add("倚天剑");  
        products.add("屠龙刀");  
        products.add("断肠草");  
        products.add("葵花宝典");  
        products.add("四十二章经");  
              
        AbstractObjectList list;  
        AbstractIterator iterator;  
          
        list = new ProductList(products); //创建聚合对象  
        iterator = list.createIterator();   //创建迭代器对象  
          
        System.out.println("正向遍历：");      
        while(!iterator.isLast()) {  
            System.out.print(iterator.getNextItem() + "，");  
            iterator.next();  
        }  
        System.out.println();  
        System.out.println("-----------------------------");  
        System.out.println("逆向遍历：");  
        while(!iterator.isFirst()) {  
            System.out.print(iterator.getPreviousItem() + "，");  
            iterator.previous();  
        }  
    }  
}  

编译并运行程序，输出结果如下：

正向遍历：

倚天剑，屠龙刀，断肠草，葵花宝典，四十二章经，

-----------------------------

逆向遍历：

四十二章经，葵花宝典，断肠草，屠龙刀，倚天剑，

如果需要增加一个新的具体聚合类，如客户数据集合类，并且需要为客户数据集合类提供不同于商品数据集合类的正向遍历和逆向遍历操作，只需增加一个新的聚合子类和一个新的具体迭代器类即可，原有类库代码无须修改，符合“开闭原则”；如果需要为ProductList类更换一个迭代器，只需要增加一个新的具体迭代器类作为抽象迭代器类的子类，重新实现遍历方法，原有迭代器代码无须修改，也符合“开闭原则”；但是如果要在迭代器中增加新的方法，则需要修改抽象迭代器源代码，这将违背“开闭原则”。

0 0