迭代子模式

概念：又称“游标模式”，可以顺序的访问一个聚集中的元素，而不必暴露聚集中的内部结构
特点：对外使用简单，可以使用户透明的访问聚集中元素，对内进行结构封装不必暴露给用户
聚集：指的是对元素封装的一个容器，可以容纳各种类型的对象（如iterator接口）
Java聚集(Collection)对象是实现了共同的java.util.Collection接口的对象（聚集对象是能够容纳一组对象的容器对象）
聚集对象提供的方法：增删改查（如Arraylist）
白箱聚集：粗俗点说 就是接口对外暴露，聚集对象实例和迭代子对象实例 都可以被客户端访问到（宽接口）

黑箱聚集：粗俗点说 就是聚集对象的接口对外暴露 而迭代子对象实例接口不对外暴露（窄接口）
demo：
白箱聚集 ：
1.定义一个抽象类（聚集工厂类）

public abstract class Aggregate {
    /**
     * 工厂方法，创建相应迭代子对象的接口（解耦）
     */
    public abstract AbstractIterator createIterator();
}

2.定义一个出现迭代子接口：用来迭代聚集对象中的元素

public interface  AbstractIterator {
    /**
     * 迭代方法：移动到第一个元素
     */
    public void first();
    /**
     * 迭代方法：移动到下一个元素
     */
    public void next();
    /**
     * 迭代方法：是否为最后一个元素
     */
    public boolean isDone();
    /**
     * 迭代方法：返还当前元素
     */
    public Object currentItem();
}

3.创建具体的聚集对象

public class ConcreteAggregate extends Aggregate {
    /**
     * 工厂方法，创建相应迭代子对象的接口
     */
    @Override
    public AbstractIterator createIterator() {
        return new ConcreteIterator(this);
    }
    private Object[] objArray = null;
    /**
     * 构造方法，传入聚合对象的具体内容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    /**
     * 取值方法：向外界提供聚集元素
     */
    public Object getElement(int index){

        if(index < objArray.length){
            return objArray[index];
        }else{
            return null;
        }
    }
    /**
     * 取值方法：向外界提供聚集的大小
     */
    public int size(){
        return objArray.length;
    }
}

4.创建具体的迭代子对象 并测试

public class ConcreteIterator  implements  AbstractIterator{
    //持有被迭代的具体的聚合对象
    private ConcreteAggregate agg;
    //内部索引，记录当前迭代到的索引位置
    private int index = 0;
    //记录当前聚集对象的大小
    private int size = 0;
    public ConcreteIterator(ConcreteAggregate agg){
        this.agg = agg;
        this.size = agg.size();
        index = 0;
    }
    /**
     * 迭代方法：返还当前元素
     */
    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
    /**
     * 迭代方法：移动到第一个元素
     */
    @Override
    public void first() {
        index = 0;
    }
    /**
     * 迭代方法：是否为最后一个元素
     */
    @Override
    public boolean isDone() {
        return (index >= size);
    }
    /**
     * 迭代方法：移动到下一个元素
     */
    @Override
    public void next() {
        if(index < size)
        {
            index ++;
        }
    }
    public static void operation(){
        Object[] objArray = {"One","Two","Three","Four","Five","Six"};
        //创建聚合对象
        Aggregate agg = new ConcreteAggregate(objArray);
        //循环输出聚合对象中的值
        AbstractIterator it = agg.createIterator();
        while(!it.isDone()){
            System.out.println(it.currentItem());
            it.next();
        }
    }
    public static void main(String[] args) {
        operation();
    }

黑箱聚集
多余的不写了，关键点在于是把创建迭代子对象的实现类改为了聚集对象的内部类，这样方法不会对外暴露，即黑箱
public class ConcreteAggregate extends Aggregate {

private Object[] objArray = null;
/**
 * 构造方法，传入聚合对象的具体内容
 */
public ConcreteAggregate(Object[] objArray){
    this.objArray = objArray;
}

@Override
public Iterator createIterator() {

    return new ConcreteIterator();
}
/**
 * 内部成员类，具体迭代子类
 */
private class ConcreteIterator implements Iterator
{
    //内部索引，记录当前迭代到的索引位置
    private int index = 0;
    //记录当前聚集对象的大小
    private int size = 0;
    /**
     * 构造函数
     */
    public ConcreteIterator(){
        
        this.size = objArray.length;
        index = 0;
    }
    /**
     * 迭代方法：返还当前元素
     */
    @Override
    public Object currentItem() {
        return objArray[index];
    }
    /**
     * 迭代方法：移动到第一个元素
     */
    @Override
    public void first() {
        
        index = 0;
    }
    /**
     * 迭代方法：是否为最后一个元素
     */
    @Override
    public boolean isDone() {
        return (index >= size);
    }
    /**
     * 迭代方法：移动到下一个元素
     */
    @Override
    public void next() {

        if(index < size)
        {
            index ++;
        }
    }
}

}