GoF之迭代器模式、访问者模式详解

迭代器（Iterator Pattern）模式
提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

优点：

1、它支持以不同的方式遍历一个聚合对象。

2、迭代器简化了聚合类。

3、在同一个聚合上可以有多个遍历。

4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

优使用场景：

1、访问一个聚合对象的内容而无须暴露它的内部表示。

2、需要为聚合对象提供多种遍历方式。

3、为遍历不同的聚合结构提供一个统一的接口。

具体实现：创建一个迭代器Iterator 接口和一个返回迭代器的 Container 接口。实现 Container 接口的实体类负责实现 Iterator 接口。用实体类 NamesRepository 来打印 NamesRepository 中存储为集合的 Names。

//创建接口:
public interface Iterator{
public boolean hasNext();
public Object next();
}

public interface Container{
public Iterator getIterator();
}

//创建实现了 Container 接口的实体类。该类有实现了 Iterator 接口的内部类 NameIterator。
public class NameRepositoryimplements Container{
public String names[] = {“XiaoLi”, “XiaoWang”, “XiaoZhang”,“XiaoLiu”};

@Override
public Iterator getIterator() {
    return new NameIterator();
}

private class NameIteratorimplements Iterator{
    int index;

    @Override
    public boolean hasNext() {
        if (index < names.length) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        if (this.hasNext()) {
            return names[index++];
        }
        return null;
    }
}

}

//使用NameRepository来获取迭代器，并打印名字
public class Client {
public static void main(String[] args) {
NameRepository namesRepository = new NameRepository()
for (Iterator iter = namesRepository.getIterator(); iter.hasNext(); ) {
Stringname = (String) iter.next();
System.out.println(“Name :” + name);
}
}
}
/*output
Name :XiaoLi
Name :XiaoWang
Name :XiaoZhang
Name :XiaoLiu
*/

访问者（Visitor Pattern）模式
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。

优点：

1、符合单一职责原则。

2、优秀的扩展性。

3、灵活性。

缺点：

1、具体元素对访问者公布细节，违反了迪米特原则。

2、具体元素变更比较困难。

3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

使用场景：

对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

具体实现：

创建一个定义接受操作的 ComputerPart 接口。Keyboard、Mouse等等是实现了 ComputerPart 接口的实体类。用ComputerPartVisitor接口定义访问者类的操作。Computer 使用实体访问者来执行相应的动作。

//定义一个表示元素的接口
public interface ComputerPart{
public void accept(ComputerPartVisitor computerPartVisitor);
}

//创建扩展ComputerPart的实体类
public class Keyboard implements ComputerPart{
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}

public class Monitor implements ComputerPart{
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}

public class Mouse implements ComputerPart{
@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
computerPartVisitor.visit(this);
}
}

//表示访问者的接口，用来定义访问者类的操作
public interface ComputerPartVisitor{
//在被访问的类里面加一个对外提供接待访问者的接口
public void visit(Computer computer);
public void visit(Mouse mouse);
public void visit(Keyboard keyboard);
public void visit(Monitor monitor);
}

//使用实体访问者来执行相应的动作
public class Computer implements ComputerPart{
ComputerPart[] parts;
public Computer() {
parts = new ComputerPart[]{new Mouse(), new Keyboard(), new Monitor()};
}

@Override
public void accept(ComputerPartVisitor computerPartVisitor) {
    for (int i = 0; i < parts.length; i++) {
        parts[i].accept(computerPartVisitor);
    }
   computerPartVisitor.visit(this);
}

}

//创建实现了上述类的实体访问者
public class ComputerPartDisplayVisitorimplements ComputerPartVisitor{

@Override
public void visit(Computer computer) {
    System.out.println("Displaying Computer.");
}

@Override
public void visit(Mouse mouse) {
    System.out.println("Displaying Mouse.");
}

@Override
public void visit(Keyboard keyboard) {
    System.out.println("Displaying Keyboard.");
}

@Override
public void visit(Monitor monitor) {
    System.out.println("Displaying Monitor.");
}

}

//使用 ComputerPartDisplayVisitor来显示 Computer 的组成部分。
public class Client {
public static void main(String[] args) {
ComputerPartcomputer = new Computer();
computer.accept(new ComputerPartDisplayVisitor());
}
}
/*output
DisplayingMouse.
DisplayingKeyboard.
DisplayingMonitor.
DisplayingComputer.
*/

更多技术分享，公众号“专注一行代码”，ID zzyhdm