设计模式17——行为型模式之迭代器模式

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

类型：对象行为型模式

概述：     

正如定义所言，迭代器是为解决更好的访问一个聚合对象中的各个元素而产生的。迭代器是对象行为模式，也即它主要是通过将对象中的访问行为提取出来作为迭代器类。迭代器的产生，主要是为了解决客户端对聚合对象内部元素访问时可能造成的耦合。

          为了使得迭代器能够访问更多的聚合对象，所以需要面向接口编程，即为迭代器和聚合对象分别提供统一接口。

          C++中的STL库、C#，Java的泛型类型都有封装迭代器，所以下面的示例重点了解迭代器的工作原理。

          举一个简单示例，有一个图书馆，存有许多图书。一天，有读者来借书，这个时候就可以使用迭代器模式了。迭代器将一系列图书的遍历查找定位等操作抽象出来形成一个迭代器类。

类图：

 

参与者：

1. Client，生成具体的NationalLibrary以及具体的ConcreteIterator对象。

2. Library，提供聚合对象的抽象接口。

3. NationalLibrary，实现接口，并返回一个ConcreteIterator的对象。

4. Iterator，迭代器接口类。

5. ConcreteIterator，完成接口实现遍历查找。

示例代码：

using System;
using System.Collections.Generic;
using System.Text;

namespace IteratorSpace
{
    class Program
    {
        abstract class Library
        {
            public abstract Iterator CreateIterator();
        }

        class NationalLibrary : Library
        {
            private IList<object> items = new List<object>();
            public override Iterator CreateIterator()
            {
                return new ConcreteIterator(this);
            }

            public int Count
            {
                get { return items.Count; }
            }

            public object this[int index]
            {
                get { return items[index]; }
                set { items.Insert(index, value); }
            }
        }

        abstract class Iterator
        {
            public abstract object First();
            public abstract object Next();
            public abstract bool End();
            public abstract object CurrentItem();
        }

        class ConcreteIterator : Iterator
        {
            private NationalLibrary library;
            private int current = 0;

            public ConcreteIterator(NationalLibrary _library)
            {
                this.library = _library;
            }

            public override object First()
            {
                return library[0];
            }

            public override object Next()
            {
                object ret = null;
                current++;

                if (current < library.Count)
                {
                    ret = library[current];
                }

                return ret;
            }

            public override object CurrentItem()
            {
                return library[current];
            }

            public override bool End()
            {
                return current >= library.Count ? true : false;
            }

        }

        static void Main(string[] args)
        {
            NationalLibrary library = new NationalLibrary();

            library[0] = "C++ Primer";
            library[1] = "C Program";
            library[2] = "Design Pattern";

            Iterator iter = new ConcreteIterator(library);

            while (!iter.End())
            {
                Console.WriteLine("This book is {0}!", iter.CurrentItem());
                iter.Next();
            }
        }
    }
}

适用性：

1. 访问一个聚合对象的内容而无需暴露它的内部表示。

2. 支持对聚合对象的多种遍历。

3. 为遍历不同的聚合结构提供一个统一的接口(即,支持多态迭代)

优缺点：

1. 优点，简化遍历过程，降低客户端与聚合对象之间的耦合性。

2. 缺点，如果是简单聚合对象使用迭代器反倒复杂，另外新添聚合类以及迭代器类过多时，也会造成类过多而复杂

参考资料：

1. 《设计模式——可复用面向对象软件基础》
2. 《大话设计模式》
3. 《Head First设计模式》