使用访问者模式时是匿名还是真实的类定义？

Question

当您使用访问者模式并且需要在访问者方法中获取变量时，如何继续？

我看到两种方法。第一个使用匿名类：

// need a wrapper to get the result (which is just a String)
final StringBuild result = new StringBuilder();
final String concat = "Hello ";

myObject.accept(new MyVisitor() {

    @Override
    public void visit(ClassA o)
    {
        // this concatenation is expected here because I've simplified the example
        // normally, the concat var is a complex object (like hashtable) 
        // used to create the result variable 
        // (I know that concatenation using StringBuilder is ugly, but this is an example !)
        result.append(concat + "A");
    }

    @Override
    public void visit(ClassB o)
    {
        result.append(concat + "B");
    }
});

System.out.println(result.toString());

优点和缺点缺点：

• 优点：您不需要为这个小行为创建一个类文件
• 缺点：我不喜欢这种情况下的“final”关键字：匿名类的可读性较差，因为它调用外部变量，并且您需要使用包装器来获取请求的值（因为使用关键字final，您无法重新分配变量）

另一种方法是创建一个外部访问者类

public class MyVisitor
{
    private String result;
    private String concat;

    public MyVisitor(String concat)
    {
        this.concat = concat;
    }

    @Override
    public void visit(ClassA o)
    {
        result = concat + "A";
    }

    @Override
    public void visit(ClassB o)
    {
        result = concat + "B";
    }

    public String getResult()
    {
        return result;
    }
}

MyVisitor visitor = new MyVisitor("Hello ");
myObject.accept(visitor);
System.out.println(visitor.getResult());

：缺点：

• 优点：所有变量都在干净的范围内定义，不需要包装器来封装请求的变量
• 缺点：需要外部文件，必须在接受方法之后调用 getResult() 方法，这非常难看，因为您需要知道函数调用顺序才能正确使用访问者

您，在这种情况下您的方法是什么？首选方法？另一个想法？

Answer 1

好吧，这两种方法都是有效的，而且在我看来，这实际上取决于您是否愿意重用代码。顺便说一句，您的最后一个“缺点”点并不完全有效，因为您不需要“外部文件”来声明类。它很可能是一个内部类...

也就是说，我使用访问者的方式是这样的：

public interface IVisitor<T extends Object> {
    public T visit(ClassA element) throws VisitorException;
    public T visit(ClassB element) throws VisitorException;
}

public interface IVisitable {
    public <T extends Object> T accept(final IVisitor<T> visitor) throws VisitorException;
}

public class MyVisitor implements IVisitor<String> {
    private String concat;

    public MyVisitor(String concat) {
        this.concat = concat;
    }

    public String visit(ClassA classA) throws VisitorException {
        return this.concat + "A";
    }

    public String visit(ClassB classB) throws VisitorException {
        return this.concat + "B";
    }
}

public class ClassA implements IVisitable {
    public <T> T accept(final IVisitor<T> visitor) throws VisitorException {
        return visitor.visit(this);
    }
}

public class ClassB implements IVisitable {
    public <T> T accept(final IVisitor<T> visitor) throws VisitorException {
        return visitor.visit(this);
    }
}

// no return value needed?
public class MyOtherVisitor implements IVisitor<Void> {
    public Void visit(ClassA classA) throws VisitorException {
        return null;
    }

    public Void visit(ClassB classB) throws VisitorException {
        return null;
    }
}

这样，被访问的对象不知道访问者想要用它们做什么，但它们确实返回访问者想要的任何内容返回。您的访问者甚至可以通过抛出异常来“失败”。

几年前我写了这个的第一个版本，到目前为止，它在任何情况下都对我有用。

免责声明：我只是将其拼凑在一起，质量（甚至编译）无法保证。但你明白了...:)

Answer 2

我没有看到您的第二个示例中实现了接口，但我相信它是存在的。我将添加到您的界面（或创建一个子界面），其中有一个 getResult() 方法。

这对示例 1 和 2 都有帮助。您不需要在示例 1 中使用包装器，因为您可以定义 getResult() 方法来返回所需的结果。在示例 2 中，由于 getResult() 是界面的一部分，因此没有“需要了解”的函数。

我的偏好是创建一个新类，除非该类的每个变体仅使用一次。在这种情况下，我会匿名内联它。

Answer 3

从更干净设计的角度来看，出于与您已经陈述的相同的确切原因，第二种方法是更可取的。

在正常的 TDD 周期中，我会从一个匿名类开始，稍后再对其进行重构。但是，如果仅在该一个地方需要访问者，并且其复杂性与您在示例中提供的内容相匹配（即不复杂），那么我会将其悬置并重构为稍后如果需要（例如出现另一个用例，访问者/周围类的复杂性增加）。

Answer 4

我建议使用第二种方法。让访问者处于成熟的类中也可以达到文档和干净代码的目的。我不同意您提到的该方法的缺点。假设你有一个数组列表，并且你没有向其中添加任何元素并执行 get 操作，那么你肯定会得到一个 null，但这并不意味着它一定是错误的。

Answer 5

访问者模式的要点之一是允许多种访问者类型。如果你创建一个匿名类，你就打破了这个模式。

您应该将 accept 方法更改为

public void accept(Visitor visitor) {
   visitor.visit(this);
}

由于您将 this 传递给访问者，this 是被访问的对象，访问者可以访问根据标准访问规则访问对象的属性。