“迭代器”设计模式与内部类

来自一个重新研读《Thinking in Java》的coder

interface Selector {
    boolean end();

    Object current();

    void next();
}

// 一个以类的形式包装起来的 固定大小的 Object 数组
public class Sequence {

    private Object[] items;
    private int next = 0;

    public Sequence(int size) {
        items = new Object[size];
    }

    public void add(Object o) {
        if (next < items.length) {
            items[next++] = o;
        }
    }

    //内部类拥有对其外部类所有成员的访问权
    private class SequenceSelector implements Selector {
        private int i = 0; //当前位置 index

        @Override
        public boolean end() {
            return i == items.length;
        }

        @Override
        public Object current() {
            return items[i];
        }

        @Override
        public void next() {
            if (i < items.length) {
                i++;
            }
        }
    }

    // "迭代器" 设计模式
    public Selector selector() {
        return new SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);
        for (int i = 0; i < 10; i++) {
            sequence.add(Integer.toString(i));  //Object
        }

        //创建内部类时，内部类秘密捕获外围类对象的引用，这个引用访问外部类的成员
        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
    }

}

使用上面的 “迭代器”

public class MyString {
    private String s;

    public MyString(String s) {
        this.s = s;
    }

    @Override
    public String toString() {
        return s;
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(6);
        for (char i = 'a'; i < 'g'; i++) {
            MyString s = new MyString(String.valueOf(i));
            sequence.add(s);
        }

        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.print(selector.current() + " ");
            selector.next();
        }
    }

}