4.11 访问者模式 (Visitor)

访问者模式（Visitor Pattern）是一种行为设计模式，它允许你在不改变元素类的前提下定义新的操作。访问者模式将操作的逻辑从对象结构中分离出来，使得新的操作可以独立于对象结构变化而变化。

主要角色

1. Visitor（访问者）: 为对象结构中的每个具体元素类声明一个visit操作。
2. ConcreteVisitor（具体访问者）: 实现每个由Visitor声明的操作。
3. Element（元素）: 定义一个accept操作，它接受一个访问者对象作为参数。
4. ConcreteElement（具体元素）: 实现Element接口，定义一个accept操作，其实现通常是调用访问者的相应方法。

类图

+-------------------+      +-------------------+
|      Visitor      |      |      Element      |
+-------------------+      +-------------------+
| + visitA(A)       |<---->| + accept(Visitor) |
| + visitB(B)       |      +-------------------+
+-------------------+               ^
        ^                            |
        |                            |
+-------------------+      +-------------------+
| ConcreteVisitor   |      | ConcreteElementA  |
+-------------------+      +-------------------+
| + visitA(A)       |      | + accept(Visitor) |
| + visitB(B)       |      +-------------------+
+-------------------+               ^
                                    |
                            +-------------------+
                            | ConcreteElementB  |
                            +-------------------+
                            | + accept(Visitor) |
                            +-------------------+

示例代码

以下是一个简单的访问者模式实现示例，使用了 Java 语言：

// 访问者接口
interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

// 具体访问者
class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA elementA) {
        System.out.println("Visiting ConcreteElementA");
        elementA.operationA();
    }

    @Override
    public void visit(ConcreteElementB elementB) {
        System.out.println("Visiting ConcreteElementB");
        elementB.operationB();
    }
}

// 元素接口
interface Element {
    void accept(Visitor visitor);
}

// 具体元素A
class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void operationA() {
        System.out.println("ConcreteElementA operation");
    }
}

// 具体元素B
class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void operationB() {
        System.out.println("ConcreteElementB operation");
    }
}

// 使用示例
public class VisitorPatternDemo {
    public static void main(String[] args) {
        Element[] elements = {new ConcreteElementA(), new ConcreteElementB()};
        Visitor visitor = new ConcreteVisitor();

        for (Element element : elements) {
            element.accept(visitor);
        }
        // Output:
        // Visiting ConcreteElementA
        // ConcreteElementA operation
        // Visiting ConcreteElementB
        // ConcreteElementB operation
    }
}

使用场景

访问者模式适用于以下场景：

1. 对象结构相对稳定: 但需要在对象结构上定义新的操作。
2. 需要对对象结构中的对象进行很多不同且不相关的操作: 这些操作彼此之间没有太多关联。
3. 对象结构中的类很少改变: 但经常需要在此结构上定义新的操作。

优缺点

优点:

1. 增加新的操作很容易: 通过增加新的访问者类，可以很容易地增加新的操作。
2. 将有关的行为集中到一个访问者对象中: 使得行为的修改和扩展变得更加容易。
3. 遵循单一职责原则: 使得类的职责更加单一。

缺点:

1. 增加新的元素类很困难: 如果需要增加新的元素类，所有的访问者类都需要修改。
2. 破坏封装: 访问者模式要求访问者对象访问并处理元素对象的内部状态，可能会破坏元素对象的封装性。

访问者模式通过将操作逻辑从对象结构中分离出来，使得新的操作可以独立于对象结构变化而变化。它在需要对对象结构进行多种操作且对象结构相对稳定的场景中非常有用。