Objective C 迭代器模式

迭代器模式(Iterator)，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

   那么一般在什么时候才会用迭代器模式呢？当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。另外，当你需要对聚集有多种方式遍历时，也可以考虑用迭代器模式。

   说了这么多，下面给大家展示一下类关系图。

   上图中Client的右边是迭代器，左边是具体迭代的类型，在迭代器内部对具体需要迭代的类型进行了引用，还算不难理解吧，呵呵。其实，看起来是为了对具体类型进行解耦。好啦，下面给出具体的代码实现，简单的模拟了迭代器模式。

• Iterator类接口

1 2 3 4 5 6 7 8

#import <Foundation/Foundation.h>                         @interface Iterator:NSObject -(id)First; -(id)Next; -(BOOL)IsDone; -(id)CurrentItem; @end

• Iterator类实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#import "Iterator.h"                       @implementation Iterator                       -(id)First{     return nil; } -(id)Next{     return nil; } -(BOOL)IsDone{     return NO; } -(id)CurrentItem{     return nil; }                       @end

• ConcreteIterator类接口

1 2 3 4 5 6 7 8 9

#import "Iterator.h"                     @class ConcreteAggregate; @interface ConcreteIterator :Iterator{     ConcreteAggregate *myAggregate;     int current; } -(ConcreteIterator*)MyInit:(ConcreteAggregate*)aggregate; @end

• ConcreteIterator类实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#import "ConcreteIterator.h" #import "ConcreteAggregate.h"                   @implementation ConcreteIterator                   -(ConcreteIterator*)MyInit:(ConcreteAggregate*)aggregate{     myAggregate = aggregate;     return self; } -(id)First{    return [myAggregate GetObject:0]; } -(id)Next{     current++;     if(current< [myAggregate GetCount])         return [myAggregate GetObject:current];     else {         return nil;     } } -(BOOL)IsDone{    return current>= [myAggregate GetCount] ?YES:NO; } -(id)CurrentItem{    return [myAggregate GetObject:current]; }                   @end

• Aggregate类接口

1 2 3 4 5 6

#import <Foundation/Foundation.h>                 @class Iterator; @interface Aggregate:NSObject -(Iterator*)CreateIterator; @end

• Aggregate类实现

1 2 3 4 5 6 7 8

#import "Aggregate.h" #import "Iterator.h"               @implementation Aggregate -(Iterator*)CreateIterator{     return [[Iterator alloc]init]; } @end

• ConcreteAggregate类接口

1 2 3 4 5 6 7 8 9

#import "Aggregate.h"             @interface ConcreteAggregate:Aggregate{     NSMutableArray *items; } -(int)GetCount; -(id)GetObject:(int)index; -(void)InsertObject:(id)Obj; @end

• ConcreteAggregate类实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

#import "ConcreteAggregate.h" #import "Iterator.h"           @implementation ConcreteAggregate           -(id)init{     if(self == [super init]){         items = [NSMutableArray new];     }     return self; } -(Iterator*)CreateIterator{     return [[Iterator alloc]init]; } -(id)GetObject:(int)index{     return [items objectAtIndex:index]; } -(void)InsertObject:(id)Obj{     [items addObject:Obj]; } -(int)GetCount{     return [items count]; }           @end

• Main方法调用

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#import <Foundation/Foundation.h> #import "ConcreteAggregate.h" #import "Iterator.h" #import "ConcreteIterator.h"      int main (int argc, const char *argv[]) {     @autoreleasepool {     ConcreteAggregate *a = [[ConcreteAggregate alloc]init];                           [a InsertObject:@"张三"];         [a InsertObject:@"李四"];         [a InsertObject:@"王二"];         [a InsertObject:@"麻子"];         NSLog(@"Count:%d", [a GetCount]);         Iterator *i = [[ConcreteIterator alloc]MyInit:a];         while (![i IsDone]) {             NSLog(@"%@，请买票",[i CurrentItem]);             [i Next];         }     }     return 0; }

   好啦，上面的四个类型简单实现了迭代器模式，其实迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部地数据。