编程-设计模式 16：迭代器模式

设计模式 16：迭代器模式

定义与目的

• 定义：迭代器模式提供一种方法来顺序访问聚合对象中封装的各个元素，而又不暴露该对象的内部表示。
• 目的：该模式的主要目的是为遍历不同的聚合结构提供一个一致的接口，使得客户端可以在不知道聚合对象内部结构的情况下遍历其元素。

实现示例

假设我们有一个菜单系统，需要支持不同的菜单结构，如列表菜单和分层菜单。我们可以使用迭代器模式来实现这个需求。

// 抽象聚合
interface Menu {
    Iterator createIterator();
}

// 抽象迭代器
interface Iterator {
    boolean hasNext();
    MenuItem next();
}

// 具体聚合 - 列表菜单
class ListMenu implements Menu {
    private List<MenuItem> items = new ArrayList<>();

    public void addItem(MenuItem item) {
        items.add(item);
    }

    @Override
    public Iterator createIterator() {
        return new ListIterator(items.iterator());
    }

    private static class ListIterator implements Iterator {
        private Iterator<MenuItem> iterator;

        public ListIterator(Iterator<MenuItem> iterator) {
            this.iterator = iterator;
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public MenuItem next() {
            return iterator.next();
        }
    }
}

// 具体聚合 - 分层菜单
class HierarchicalMenu implements Menu {
    private List<MenuItem> items = new ArrayList<>();

    public void addItem(MenuItem item) {
        items.add(item);
    }

    @Override
    public Iterator createIterator() {
        return new HierarchicalIterator(items.iterator());
    }

    private static class HierarchicalIterator implements Iterator {
        private Iterator<MenuItem> iterator;

        public HierarchicalIterator(Iterator<MenuItem> iterator) {
            this.iterator = iterator;
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public MenuItem next() {
            return iterator.next();
        }
    }
}

// 具体元素 - 菜单项
class MenuItem {
    private String name;

    public MenuItem(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Menu listMenu = new ListMenu();
        listMenu.addItem(new MenuItem("Coffee"));
        listMenu.addItem(new MenuItem("Tea"));

        Menu hierarchicalMenu = new HierarchicalMenu();
        hierarchicalMenu.addItem(new MenuItem("Burger"));
        hierarchicalMenu.addItem(new MenuItem("Fries"));

        Iterator listIterator = listMenu.createIterator();
        while (listIterator.hasNext()) {
            MenuItem item = listIterator.next();
            System.out.println(item.getName());
        }

        Iterator hierarchicalIterator = hierarchicalMenu.createIterator();
        while (hierarchicalIterator.hasNext()) {
            MenuItem item = hierarchicalIterator.next();
            System.out.println(item.getName());
        }
    }
}

使用场景

• 当你需要提供一个一致的方法来遍历不同的聚合结构时。
• 当你不希望客户端知道聚合对象的内部结构时。

迭代器模式通过为遍历不同的聚合结构提供一个一致的接口，使得客户端可以在不知道聚合对象内部结构的情况下遍历其元素。这对于需要遍历不同类型的聚合结构的场景非常有用。

小结

迭代器模式是一种常用的行为型模式，它可以帮助你为遍历不同的聚合结构提供一个一致的接口。这对于需要遍历不同类型的聚合结构的场景非常有用。