迭代器模式

迭代器模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象

 

迭代器模式结构：

抽象迭代子角色：此抽象角色定义出遍历元素所需的接口

具体迭代子角色：实现抽象迭代器接口，并保持迭代过程中的游标位置

抽象聚集角色：此抽象角色给出创建迭代子对象的接口

具体聚集角色：实现抽象聚集对象的接口，并返回一个合适的具体迭代子实例

客户端角色：持有对聚集及其迭代子对象的引用，调用迭代子对象的迭代接口，也有可能通过迭代子操作聚集元素的增加和删除

 

1. 白箱聚集（外禀迭代子）：  
2.         //抽象聚集角色  
3.         public abstract class Aggregate{  
4.             //工厂方法返回一个迭代子  
5.             public Iterator createIterator(){  
6.                 return null;  
7.             }  
8.         }  
9.           
10.         //抽象迭代子角色  
11.         public interface Iterator{  
12.             //迭代方法：移动到第一个元素  
13.             void first();  
14.               
15.             //迭代方法：移动到下一个元素  
16.             void next();  
17.               
18.             //迭代方法：是否是最后一个元素  
19.             boolean isDone();  
20.               
21.             //迭代方法：返回当前元素  
22.             Object currentItem();   
23.         }  
24.           
25.         //具体聚集角色  
26.         public class ConcreteAggregate extends Aggregate{  
27.             private Object[] obj = {  
28.                 "Monk Tang",  
29.                 "Monkey",  
30.                 "Pigsy",  
31.                 "Sandy",  
32.                 "Horse"  
33.             };  
34.               
35.             //工厂方法：返回一个迭代子对象  
36.             public Iterator creteIterator(){  
37.                 return new ConcreteIterator(this);  
38.             }  
39.               
40.             //取值方法：向外界提供聚集元素  
41.             public Object getElement(int index){  
42.                 if(index < obj.length){  
43.                     return obj[index];  
44.                 }else{  
45.                     return null;  
46.                 }  
47.             }  
48.               
49.             //取值方法，向外界提供聚集大小  
50.             public int size(){  
51.                 return obj.length;  
52.             }  
53.         }  
54.           
55.         如果一个对象的内部状态在对象被创建之后就不再变化，这个对象就称为不变对象。如果一个聚集对象的内部状态可以改变的话  
56.         那么在迭代过程中，一旦聚集元素发生改变（比如一个元素被删除，或者一个新的元素被加进来），就会影响到迭代过程，使迭代无法  
57.         给出正确的结果。  
58.           
59.         //具体《迭代子》角色  
60.         public class ConcreteIterator implements Iterator{  
61.             private ConcreteAggregate agg;  
62.             private int index = 0;  
63.             private int size = 0;  
64.               
65.             public ConcreteIterator(ConcreteAggregate agg){  
66.                 this.agg = agg;  
67.                 size = agg.size();  
68.                 index= 0;  
69.             }  
70.               
71.             public void first(){  
72.                 index= 0;  
73.             }  
74.               
75.             public void next(){  
76.                 if(index < size){  
77.                     index++;  
78.                 }  
79.             }  
80.               
81.             public boolean isDone(){  
82.                 return (index >= size);  
83.             }  
84.               
85.             public Object currentItem(){  
86.                 return agg.getElement(index);  
87.             }  
88.         }  
89.           
90.         //客户端  
91.         public class Client{  
92.             private Iterator it;  
93.             private Aggregate agg = new ConcreteAggregate();  
94.               
95.             public void operation(){  
96.                 it = agg.createIterator();  
97.                   
98.                 while(!it.isDone()){  
99.                     System.out.println(it.currentItem().toString());  
100.                     it.next();  
101.                 }  
102.             }  
103.               
104.             public static void main(String args[]){  
105.                 Client client = new Client();  
106.                 client.operation();  
107.             }  
108.         }