设计模式之 迭代器模式

最近偷空看《JAVA与设计模式》，关于设计模式的重要性，有人戏称如侠客练剑，模式如剑招，先学剑招，再贯通，最后无招胜有招，想当年令狐冲也是这么走过来的。嘿嘿~~ 细细看了Iterator pattern，又在google上看了些别人的帖子，有点感觉，写下来当读书笔记。 在BOF的《设计模式》一书中，他给Iterator pattern 下了一个定义：提供了一种方法顺序访问聚合对象中的各个元素，使得不暴露该对象的内部表示。该定义的前半句很好理解，其实就是迭代，但是，迭代可以避免对象内部实现的暴露这个功能却是不好理解的。 Iterator pattern的构建一般要求具备以下四个参与者： 1 Iterator 负责定义和遍历聚集对象的元素的接口。这一接口中定义了遍历元素需要的各种方法，包括hasNext()方法以及next()方法。 2 容器 有的文档也称Aggregate。类如Collection，ArrayList的集合类，一般只需要具备一个方法：iterator()，返回具体迭代类的对象实例。 3 具体Iterator        Iterator的实现。具体实现hasNext()方法以及next()方法。 4 具体容器 容器接口的实现。 来个例子：LabExam中保存了一系列实验室检查结果，要求遍历LabExam中的所有实验室检查。

/* 

* Ieterator.java 

*/ 

Public interface Ieterator{ 

       Public abstratic Boolean hasNext(); 

       Public abstract Boolean Next(); 

} 



/* 

* Aggregate.java 

*/ 

Public interface Aggregate{ 

       Public abstract Iterator iterator(); 

} 



/* 

* ConcreteIterator.java 

*/ 

Public class ConcreteIterator implements Iterator{ 

private LabExam labExam; 

       private Integer index; 

       public ConcreteIterator(LabExam labExam){ 

       this.labExam=labExam; 

       index=0; 

} 

Public Boolean hasNext(){ 

       Return index<labExam.getLength()? True:false; 

} 



Public Boolean next(){ 

       LabExaminationDetail led=labExam.getLabExamDetail(index); 

       Index++; 

       Return led; 

} 

} 



/* 

* LabExamDetail.java 

*/ 

Public class LabExamDetail{ 

     Private String examName; 

     Public LabExamDetail(String name){ 

                   This.examName=name; 

} 

Public String getName(){ 

        Return examName; 

} 

} 



/* 

* ConcreteAggregate.java 

*/ 

Public class LabExam implements Aggregate{ 

      Private LabExamDetail[] details; 

            Private Integer last 

            Public LabExam(Integer num){ 

            This.details=new LabExamDetail[num]; 

            Last=0; 

            } 

            Public void addDetail(LabExamDetail detail){ 

              This.details[last]=detail; 

              Last++; 

            } 

            Public LabExamDetail getLabExamDetail(Integer index){ 

              Return details 

            } 

            Public Integer getLength(){ 

              Return last; 

            } 

            Public Iterator iterator(){ 

              Return new ConcreteIterator(this); 

            } 
有了上面的基础，想实现遍历LabExam就很简单了。只要轻松几句代码就OK； 
            Iterator it=labExam.iterator(); 
            While(it.hasNext()){ 
              LabExamDetail detail=( LabExamDetail)it.next(); 
              System.err.println(Detail.getName()); 
            } 
} 
其实如果单纯是为了遍历，根本无需大费周章来用这么一个迭代模式，但是，它所带来的意义却是深远的。 
首先，LabExam跟ConcreteIterator是耦合的，配对的。如果想实现在一个聚合对象上创建多个迭代，OK，没问题，那就创建多个ConcreteIterator吧。在LabExam.java中也就对象有多个iterator()方法了。 
其实，采用同样的Iterator与Aggregate接口，可以多次用在不同的迭代中；例如，创建另外一对实现：LabExam2与ConcreteIterator2，分别实现上面的接口； 
再次，上面的例子中，labExam其实是用array来保存所有实验室检查项目， array有array的不足，比如说，长度固定，没法变动。假如哪天心血来潮，要求用java.util.Vector来充当容器，那么，我只要对LabExam.java稍作修改，根本无需修改上面while循环的半句代码。这就是代码复用的典型代表，也是不难明白为什么采用Iterator it=labExam.iterator() 而不用ConcreteIterator it=labExam.iterator(); 
最后，整个遍历过程，是通过iteraor(）方法生成ConcreteIterator实例对象，就调用Iterator接口的hasNext以及next方法，完全没有暴露LabExam的内部表示。这也就解释了Gang of Four所下的定义了。