设计模式--迭代器模式

1.定义

迭代器模式依赖于一个迭代器接口，提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

2.模式介绍

2.1.模式中的角色

• 迭代器
  迭代器通常拥有一个接口，此接口中一般需要hasNext()、next()、remove()等方法，可以有任意个类实现此接口创建自己独特的迭代器。
• 聚合
  聚合通常一样拥有一个接口，此接口中一般需要一个返回迭代器接口的方法createIterator()，任意一个类都可以实现接口并且实现其中的createIterator()方法来创建一个聚合类。

2.2.类图

3.测试代码

迭代器接口

/**
 * 迭代器接口
 */
public interface Iterator {
    boolean hasNext();

    Object next();

    void remove();
}

聚合接口

/**
 * 聚合接口
 */
public interface Aggregate {
    Iterator createIterator();
}

具体迭代器：

/**
 * 具体迭代器类，将传入的聚合对象封装成符合规范的迭代器
 */
public class ConcreteIterator implements Iterator {

    public List names;
    private int index = 0;

    public ConcreteIterator(List names) {
        if (names == null) {
            names = new ArrayList();
        }
        this.names = names;
    }

    @Override
    public boolean hasNext() {
        return (index < names.size()) && (names.get(index) != null);
    }

    @Override
    public Object next() {
        Object o = names.get(index);
        index++;
        return o;
    }

    @Override
    public void remove() {
        if (index <= 0) {
            return;
        }
        names.remove(names.get(index));
    }
}

具体聚合类

/**
 * 具体聚合类，管理聚合对象，通过createIterator将生成符合规范的的迭代器
 */
public class ConcreteAggregate implements Aggregate {

    List list = new ArrayList();

    public ConcreteAggregate() {
        addItem("张1");
        addItem("张2");
        addItem("张3");
        addItem("张4");
        addItem("张5");
        addItem("张6");
    }


    public void addItem(String name) {
        list.add(name);
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(list);
    }
}

测试入口

public class InitMain {
    public static void main(String[] args) {
        /**
         * 迭代器模式依赖于一个迭代器接口
         * 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示
         *
         * 设计原则
         * 单一责任原则：一个类应该只有一个引起变化的原因
         *  设计中我们要尽量避免类内部的改变，因为修改代码很容易造成许多潜在的错误。
         *  如果一个类具有两个改变的原因，就会使得将来该类的变化的几率上升。而这个原则告诉我们将一个责任只指派给一个类。
         */


        ConcreteAggregate aggregate = new ConcreteAggregate();

        Iterator iterator = aggregate.createIterator();

        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }


    }
}

4.单一责任原则

一个类应该只有一个引起变化的原因，设计中我们要尽量避免类内部的改变，因为修改代码很容易造成许多潜在的错误。如果一个类具有两个改变的原因，就会使得将来该类的变化的几率上升。而这个原则告诉我们将一个责任只指派给一个类。

5.总结

迭代器模式分离了集合的遍历行为，抽象出一个迭代器类，这样可以不暴露内部机构，又可让外部代码透明地访问集合内部的数据。