设计模式*迭代模式

迭代模式在日常的应用中几乎是无处不在，但是因为Java内部已经实现对集合对象的迭代，所以好像这种模式不常用，其实是用到了，只是没觉察到，今天就在这里剖析其中的秘密。 


先看看迭代模式的类图： 



关于迭代模式： 
迭代模式提供了一种不暴漏集合对象的内部结构，又可以迭代该集合的方法， 
关于迭代模式分离的集合对象的遍历行为，抽象出一个迭代类负责遍历，这样就做到了 
不暴漏集合对象的内部结构，可以让外部代码透明的访问集合对象内部。 

结构： 
一个抽象的迭代类，定义了抽象的迭代方法； 
一个抽象迭代类的子类，覆盖了父类的所有抽象迭代方法 
该子类依赖聚集类的子类 

一个抽象的聚集类，定义了创建的迭代类的抽象方法 
一个抽象聚集类的子类，覆盖了父类的所有的抽象方法 
该子类关联迭代类的子类 

根据上面的描述，接下来看代码： 

抽象的迭代类： 

Java代码  

1. //创建抽象的迭代类，定了的抽象的迭代方法  
2. public abstract class Iterator {  
3.     public abstract String First();  
4.     public abstract String Next();  
5.     public abstract boolean IsDone();  
6.     public abstract String CurrentItem();     
7. }  

抽象迭代类的子类 

Java代码  

1. //创建具体的迭代类，需要关联具体的聚集类  
2. public class ConcreteIterator extends Iterator {  
3.     private ConcreteAggregate aggregate;  
4.     private int index=0;  
5.       
6.     //定义迭代器的构造方法，使用一个聚集类作为入口参数  
7.     public ConcreteIterator(ConcreteAggregate aggregate){  
8.         this.aggregate = aggregate;       
9.     }  
10.       
11.     //覆盖了父类的所有的抽象方法  
12.     @Override  
13.     public String CurrentItem() {  
14.         return aggregate.getItem(index);  
15.     }  
16.   
17.     @Override  
18.     public String First() {  
19.         return aggregate.getItem(0);  
20.     }  
21.       
22.     @Override  
23.     public String Next() {  
24.         String ret="";        
25.         if (!IsDone()){  
26.             ret = aggregate.getItem(index);  
27. index +=1 ;  
28.         }  
29.         return ret;  
30.     }  
31.   
32.     @Override  
33.     public boolean IsDone() {  
34.         boolean ret;  
35.         if (index >= aggregate.getCount()){  
36.             ret = true;  
37.         }else{  
38.             ret = false;  
39.         }  
40.         return ret;  
41.     }  
42. }  

抽象聚集类 

Java代码  

1. //创建抽象的聚集类  
2. public abstract class Aggregate {  
3.     public abstract Iterator CreateIterator();  
4. }  

抽象聚集类的子类 

Java代码  

1. //创建具体的聚集类，该类依赖ConcreteAggregate  
2. public class ConcreteAggregate extends Aggregate{  
3.     private List<String> items = new ArrayList<String>();  
4.       
5.     @Override  
6.     public Iterator CreateIterator() {  
7.         return new ConcreteIterator(this);  
8.     }  
9.       
10.     public int getCount(){  
11.         return items.size();  
12.     }  
13.       
14.     public String getItem(int index){  
15.         return items.get(index);  
16.     }  
17.       
18.     public void setItem(String msg){  
19.         items.add(msg);  
20.     }  
21. }  

客户端代码 

Java代码  

1. public class Test {  
2.     public static void main(String[] args) {  
3.         //创建一个集合对象  
4.         ConcreteAggregate aggregate = new ConcreteAggregate();  
5.         aggregate.setItem("AAAA");  
6.         aggregate.setItem("BBBB");  
7.         aggregate.setItem("CCCC");  
8.         aggregate.setItem("DDDD");  
9.           
10.         //创建一个该集合的迭代器，把集合作为参数传入  
11.         Iterator i = new ConcreteIterator(aggregate);  
12.         String x;         
13.         while(!i.IsDone()){  
14.             x = i.Next();  
15.             putln(x);  
16.         }  
17.     }     
18.     public static void putln(Object o){  
19.         System.out.println(o);  
20.     }  
21. }  

运行结果： 

AAAA 
BBBB 
CCCC 
DDDD 

在回到上面的图中，在这个类图中可以看出： 
迭代器类继承了抽象的迭代器 
聚集类继承了抽象的父类， 
但是ConcreteIterator和ConcreteAggregate是关联关系， 
而 ConcreteAggregate和ConcreteIterator是依赖关系。 

一点题外话： 
这里有必要说明一下关联和依赖的区别，这两个概念其实很容易混淆 
依赖是一个弱得关联，如果一个类A依赖一个类B，那么在A中B有3中用法: 
B是全局的 
B被实例化 
B被作为参数传递 

关联代表一种结构化的关系，表现为一个对象能获得另一个对象的实例引用并且调用它的服务， 
依赖则是调用了一个对象的服务 

关联还有单双向之分，双向关联，AB两个类，如果双向关联，则互为对方的Attribue,单向关联就是一个是另一个的Attribute 
依赖则只有单向的 

在ConcreteIterator中存在 

Java代码  

1. ConcreteAggregate aggregate;  

因此ConcreteAggregate 是ConcreteIterator的属性，属于关联关系 

在ConcreteAggregate中存在 

Java代码  

1. new ConcreteIterator(this);  

ConcreteIterator 被实例化了，因此ConcreteAggregate 依赖 ConcreteAggregate 

• 
• 大小: 51.9 KB