java - 简化的访客模式

Question

这是一个用 Java 实现的访问者模式，用于计算像 (1 + 2) + 3 这样的表达式。这里的代码的灵感来自代码示例:https://en.wikipedia.org/wiki/Visitor_pattern#Sources .

interface Node
{
    public int accept(Visitor v);
}

class ConstantNode implements Node
{
    public int constant;

    public ConstantNode(int constant)
    {
        this.constant = constant;
    }

    public int accept(Visitor v) {
        return v.visit(this);
    }
}

class SumNode implements Node
{
    public Node left;
    public Node right;

    public SumNode(Node left, Node right)
    {
        this.left = left;
        this.right = right;
    }

    public int accept(Visitor v) {
        return v.visit(this);
    }
}

interface Visitor
{
    public int visit(ConstantNode n);
    public int visit(SumNode n);
}

class EvalVisitor implements Visitor
{
    public int visit(ConstantNode n) {
        return n.constant;
    }

    public int visit(SumNode n) {
        return n.left.accept(this) + n.right.accept(this);
    }
}

public class VisitorDemo
{
    public static void main(String[] args)
    {
        // First make an expression tree to represent the following.
        //
        //        +
        //       / \
        //      +   3
        //     / \
        //    1   2
        Node a = new ConstantNode(1);
        Node b = new ConstantNode(2);
        Node c = new ConstantNode(3);
        Node d = new SumNode(a, b);
        Node e = new SumNode(d, c);

        Visitor visitor = new EvalVisitor();
        int result = e.accept(visitor);
        System.out.println(result);
    }
}

我知道在每个递归级别，要调用哪个 visit() 方法取决于访问者的类型(在本例中为 evalVisitor)以及节点的类型(ConstantNode 或 SumNode)，因此需要双重分派(dispatch)。但是这种使用 accept() 和 visit() 方法实现双重调度的编码对我来说似乎太复杂了。但是我见过的几乎所有访问者模式的例子都使用这种方法，通过 accept() 将访问者传递给节点，然后调用访问者的 visit() 方法来执行双重调度。

为什么代码示例不能像这样更简单？

interface Node
{
}

class ConstantNode implements Node
{
    public int constant;

    public ConstantNode(int constant)
    {
        this.constant = constant;
    }
}

class SumNode implements Node
{
    public Node left;
    public Node right;

    public SumNode(Node left, Node right)
    {
        this.left = left;
        this.right = right;
    }
}

interface Visitor
{
    public int visit(Node n) throws Exception;
}

class EvalVisitor implements Visitor
{
    public int visit(Node n) throws Exception {
        if (n instanceof ConstantNode) {
            return ((ConstantNode) n).constant;
        } else if (n instanceof SumNode) {
            return this.visit(((SumNode) n).left) + this.visit(((SumNode) n).right);
        } else {
            throw new Exception("Unsupported node");
        }
    }
}

public class SimpleVisitorDemo
{
    public static void main(String[] args) throws Exception
    {
        // First make an expression tree to represent the following.
        //
        //        +
        //       / \
        //      +   3
        //     / \
        //    1   2
        Node a = new ConstantNode(1);
        Node b = new ConstantNode(2);
        Node c = new ConstantNode(3);
        Node d = new SumNode(a, b);
        Node e = new SumNode(d, c);

        Visitor visitor = new EvalVisitor();
        int result = visitor.visit(e);
        System.out.println(result);
    }
}

在此代码示例中，我完全消除了在每个节点中实现 apply() 的需要，并且包括双重分派(dispatch)逻辑在内的全部访问逻辑现在仅包含在访问者类中。

我有以下问题:

您能否客观地列举简化访客模式在代码的可维护性或效率方面存在的问题？

Answer 1

Why can't the code examples be simpler, [...]

因为您的示例将虚拟分派(dispatch)替换为 switch 分派(dispatch)(您将其实现为对象子类型上的 if 链)。这种方法极难维护，因为编译器无法帮助您检测继承层次结构的更改。

简化实现的具体问题在于最后一个 else，您在其中返回零。一个更常见的解决方案是在那里抛出异常，因为你真的不知道你有什么样的节点。

现在想象一下用 SubtractNode 扩展层次结构。这自然需要向 Visitor 接口(interface)添加一个方法，确保所有访问者在编译时都被迫处理新的节点子类型。

另一方面，简化示例会继续编译，在您的情况下，它也会继续运行，为 SubtractNode 返回错误结果。