迭代子模式（Iterator）

/**
 * 抽象迭代子模式
 */
public interface Iterator
{
    /*
    * 迭代方法：移动到第一个元素
    * */
    void first();
    void next();
    boolean isDone();
    Object currentItem();
 }

/**
 * 具体迭代子模式
 */
public class ConcreteIterator implements Iterator
{
    private ConcreteAggregate agg;
    private int index=0;
    private int size=0;
    public ConcreteIterator(ConcreteAggregate agg)
    {
        this.agg=agg;
        size=agg.size();
        index=0;
    }
    @Override
    public void first() {
        index=0;
    }

    @Override
    public void next() {
        if(index<size)
        {
            index++;
        }
    }

    @Override
    public boolean isDone() {
        return (index>=size);
    }

    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
}

/**
 * 抽象聚集角色Aggregate
 */
public abstract class Aggregate
{
    /*
    * 工厂方法：返回一个迭代子对象
    * */
    public Iterator createIterator()
    {
        return null;
    }
}

/**
 * 具体聚集角色
 */
public class ConcreteAggregate extends Aggregate
{
    private Object[] objs={"Monk Tang","Monkey","Pigsy","Sandy","Horse"};
    public Iterator createIterator()
    {
        return new ConcreteIterator(this);
    }
    /*
    * 取值方法：向外界提供聚集方法
    * */
    public Object getElement(int index)
    {
        if(index<objs.length)
        {
            return objs[index];
        }
        else
        {
            return null;
        }
    }
    public int size()
    {
        return objs.length;
    }
}

public class Client
{
    private Iterator it;
    private Aggregate agg=new ConcreteAggregate();
    public void operation()
    {
        it=agg.createIterator();
        while(!it.isDone())
        {
            System.out.println(it.currentItem().toString());
            it.next();
        }
    }

    public static void main(String[] args) {
        Client client=new Client();
        client.operation();
    }
}