设计模式之Iterator模式

在之前一篇文章《Java设计模式之六大设计原则》中说到了，设计模式是为了增强代码的可复用性，可拓展性，可维护性，灵活性。也说到几个设计模式的理论知识。这篇文章中主要讲一下Iterator设计模式，贯穿一种面向接口编程的思想，并且印证设计原则。

       我们以一个书架的遍历为例子来讲解说明。现在，我希望定义一个简单的书架，这个书架上可以放书，还需要能遍历这个书架。我们先来看看传统的设计思想。如果按普通的面向实现的编程思想，这很简单。首先，定义一个书架BookShelf类，在这个类中有一个数组books，用于存放书籍。还有一个用于添加书籍的方法appendBook方法，在这个方法中把添加进来的书籍存放到数组中。再有一个getBooks方法返回存放书籍的对象books数组，然后就可以去for循环遍历这个books数组，或者提同一个getBookAt方法直接根据下标来获取书籍，这就达到了我们的目的。这儿就不再写这种代码了，有兴趣的朋友可以自己写一份出来，跟下面的示例代码进行比较。

       然而我今天讲的并不是这么简单的用这种面向实现的方式去实现，因为种编码方式写出来的代码可维护性，灵活性，可复用性很差。因为数组是定长的，不灵活，如果有一天，突然不能用数组去存放书籍了，而是用List集合存放书籍，那可以想一下，我们需要改哪些东西。首先我们需要改书架BookShelf这个类，然后还要更改BookShelf的调用者，这种方式绝对不可取。为什么不可取，我们来看一看瞧一瞧。

      我们先来看看另一种设计思想，再看代码，然后再来说为啥这样用不好。
      首先我们来看，这儿的书架BookShelf类有两个功能。第一，存放书籍。第二，遍历书籍。为了单一职责法则，我想把书架的功能细化，那我就要将遍历书籍这个功能独立出来，用一个迭代器去实现这个功能，并且增加接口来实现。将传统的面向实现过程编程转变为面向接口和抽象编程。这样就弱化了类之间的耦合性，增强了代码的复用性，可维护性和灵活性。
      我们再来看看具体实现，首先我需要定义一个Iterator接口，实现该接口的类用于迭代书架。该接口很简单，有两个个抽象方法，hasNext方法和next方法，用于判断是否还有下一个元素，返回下一个函数。

/**
 * Created by PICO-USER on 2017/3/8.
 */

public interface Iterator {

    public abstract boolean hasNext();

    public abstract Object next();

}

 接着定义一个Aggregate接口，实现该接口的类，可以返回一个Iterator迭代器。iterator方法返回一个迭代器。

/**
 * Created by PICO-USER on 2017/3/8.
 */

public interface Aggregate {

    public abstract Iterator iterator();
}

现在就需要一个书籍Book类，可以返回书籍的名称。该类就是一个简单的model。

/**
 * Created by PICO-USER on 2017/3/8.
 */

public class Book {

    private String bookName;

    public Book(String bookName) {

        this.bookName = bookName;
    }

    public String getBookName() {
        return bookName;
    }
}

我们有了一个迭代器接口，并且BookShelf也打算把遍历功能给迭代器管理了。那现在我们还需要一个具体的迭代器类BookShelIterator，这个类就是用于遍历功能的管理了，实现了Iterator接口，实例化该类的时候，需要提供一个BookShelf类的对象，用于管理这个对象的一切遍历工作。

/**
 * Created by PICO-USER on 2017/3/8.
 */

public class BookShelfIterator implements Iterator {

    private BookShelf bookShelf;
    private int index;

    public BookShelfIterator(BookShelf bookShelf) {

        this.bookShelf = bookShelf;
    }

    @Override
    public boolean hasNext() {
        if (index < bookShelf.getLength()) {
            return true;
        }

        return false;
    }

    /**
     * 该方法返回当前这本书，并把下标指向下一本书
     * @return
     */
    @Override
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        index++;
        return book;
    }
}

最后需要一个书架BookShelf类，该类实现了Aggregate接口，因为我们需要遍历书架上的书籍，并且将遍历的功能赋予了迭代器，所以需要一个暴露出迭代器对象用于遍历，注意这儿很关键。我们这儿将遍历的功能给了迭代器，达到了将遍历的功能独立出来的效果，这样就达到了单一原则和迪米特法则。我们不用去操作BookShelf中的任何数据和任何方法就能遍历书架，有人想问，你都iterator返回一个迭代器了，你还说没有调用他的方法，注意了，我们这儿是接口Aggregate的方法，他只是去实现了而已，并且我们不需要去操作他的数组或者getBookAt方法了啊！也就是说不论你BookShelf中怎么变，只要你能给我一个迭代器，调用者不需要你的任何东西，调用者就能实现遍历功能。

/**
 * Created by PICO-USER on 2017/3/8.
 */

public class BookShelf implements Aggregate {

    // private Book[] books;
    private List books;
    private int last;

    /*public BookShelf(int capacity) {
        books = new Book[capacity];
    }*/

    public BookShelf() {
        books = new ArrayList<>();
    }

    /*public void appendBook(Book book) {
        books[last] = book;
        last++;
    }*/
    public void appendBook(Book book) {
        books.add(book);
        last++;
    }

   /* public int getLength() {

        return books.length;
    }*/

    public int getLength() {

        return books.size();
    }

    /*public Book getBookAt(int index) {

        return books[index];
    }*/


    public Book getBookAt(int index) {

        return books.get(index);
    }

    @Override
    public Iterator iterator() {
        return new BookShelfIterator(this);
    }
}

最后来看看调用的代码：很简单就是先往书架上放书，然后遍历。

public class IteratorRun {

    public static void main(String[] args0) {

        BookShelf bookShelf = new BookShelf();
        bookShelf.appendBook(new Book("Around the world in 80 day"));
        bookShelf.appendBook(new Book("Bible"));
        bookShelf.appendBook(new Book("Cinderella"));
        bookShelf.appendBook(new Book("Daddy-Long-Legs"));
        bookShelf.appendBook(new Book("Snow White and the Seven Dwarfs"));
        Iterator iterator = bookShelf.iterator();
        while (iterator.hasNext()) {
            Book book = (Book) iterator.next();
            System.out.print(book.getBookName() + "\n");
        }
    }
}

可以看到上面BookShelf中有一些注释掉的代码，并且还有同名的方法在用，那是因为注释掉的代码是用于用数组存放书籍的情况。正在用的代码是用List存放书籍。这儿看到了吗？我没有修改出BookShel之外的任何代码就实现了数组和List的切换。这就是代码的复用性，可维护性，灵活性的体现。