为什么我们通过调用Acceptor.accept()而不是Visitor.visit()来启动Visitor？

Question

在Wikipedia 样本和GoF书中,访问者模式的使用是通过accept在某个接受者上调用方法来启动的.但为什么会这样呢？为什么我们不能开始visit用所需的接受器作为参数调用方法？我们仍然可以使访问者行为依赖于两种类型 - 访问者和接受者(双重调度) - 并且我们可以消除冗余呼叫(在我看来).

这是用于说明这一点的示例代码:

public interface Visitor {
    void visit(AcceptorA acceptor);
    void visit(AcceptorB acceptor);
}

//
// Visitor which sings
// 
class SingingVisitor implements Visitor {
    public void visit(AcceptorA acceptor) {
        System.out.println("sing A");
    }

    public void visit(AcceptorB acceptor) {
        System.out.println("sing B");
    }
}


//
// Visitor which talks
// 
class TalkingVisitor implements Visitor {
    public void visit(AcceptorA acceptor) {
        System.out.println("talk A");
    }

    public void visit(AcceptorB acceptor) {
        System.out.println("talk B");
    }
}

//
// Acceptor subclasses
// 
class AcceptorA implements BaseAcceptor {
}

class AcceptorB implements BaseAcceptor {
}

//
// Launcher class
// 
class VisitorMain {
    public static void main(String[] args) {
        Visitor v = new TalkingVisitor();
        AcceptorA a = new AcceptorA();
        AcceptorB b = new AcceptorB();

        v.visit(a);
        v.visit(b);
        v = new SingingVisitor();
        v.visit(a);
        v.visit(b);
    }
}

Answer 1

使用您的版本,以下将无法编译:

List<BaseAcceptor> list = ...
for(BaseAcceptor ba: list)
   vi.visit(ba)

java编译器无法(静态地)确定将是什么ba,因此它无法在编译时决定访问哪种方法来调用.您需要编写其他方法:

public void visit(BaseAcceptor ba){
   if(ba instanceof AcceptorA) 
     visit((AcceptorA)ba);
   else if(ba instanceof AcceptorB) 
     visit((AcceptorB)ba);
}

使用访客模式不需要这样做.

Answer 2

考虑:

class House implements HouseAcceptor {
    HouseAcceptor kitchen;
    HouseAcceptor livingRoom;

    void accept(HouseVisitor visitor) {
        visitor.visit(this);
        kitchen.accept(visitor);
        livingRoom.accept(visitor);
    }
}

class Kitchen implements HouseAcceptor {
    void accept(HouseVisitor visitor) {
        visitor.visit(this);
    }
}

class LivingRoom implements HouseAcceptor {
    void accept(HouseVisitor visitor) {
         visitor.visit(this);
    }
}

class SpeakingHouseVisitor implements HouseVisitor {
    void visit(HouseAcceptor acceptor) {
        System.out.println("Inside a HouseAcceptor");
    }

    void visit(House acceptor) {
        System.out.println("Inside a House");
    }

    void visit(Kitchen acceptor) {
        System.out.println("Inside a Kitchen");
    }

    void visit(LivingRoom acceptor) {
        System.out.println("Inside a LivingRoom");
    }
}

...
HouseAcceptor acceptor = new House();
HouseVisitor visitor = new SpeakingHouseVisitor();

...
// Doing it your way
visitor.visit(acceptor);
// Output: Inside a HouseAcceptor

// Doing it the right way
acceptor.accept(visitor);
// Output:
// Inside a House
// Inside a Kitchen
// Inside a LivingRoom

请注意,如果按照自己的方式执行,接受器的运行时类型将没有区别:将使用静态类型.通过执行双重调度,您可以确保使用两种运行时类型.