Java-访问者-设计模式（二十）_java的访问者模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_44607611/article/details/113481009

说明

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

UML
在这里插入图片描述
角色：
Visitor 抽象访问者角色：为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就可以通过该元素角色的特定接口直接访问它。
ConcreteVisitor.具体访问者角色：实现Visitor声明的接口。
Element：定义一个接受访问操作(accept())，它以一个访问者(Visitor)作为参数。
ConcreteElement 具体元素：实现了抽象元素(Element)所定义的接受操作接口。
ObjectStructure 结构对象角色：这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素；如有需要，可以设计成一个复合对象或者一个聚集（如一个列表或无序集合）。

代码

以《大话设计模式》中该模式的基本代码为例，代码如下。

Visitor，为该对象结构中具体元素角色声明一个访问操作接口。

/**
 * @author ctl
 * @date 2021/1/29
 */
public interface Visitor {

    void visitConcreteElementA(ConcreteElementA concreteElementA);

    void visitConcreteElementB(ConcreteElementB concreteElementB);
}

ConcreteVisitor1,具体访问者

/**
 * @author ctl
 * @date 2021/1/29
 */
public class ConcreteVisitor1 implements Visitor {

    @Override
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName() + "被"
                + this.getClass().getSimpleName() + "访问");
        concreteElementA.operationA();
    }

    @Override
    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
        System.out.println(concreteElementB.getClass().getSimpleName() + "被"
                + this.getClass().getSimpleName() + "访问");
        concreteElementB.operationB();
    }
}

ConcreteVisitor2，具体访问者

/**
 * @author ctl
 * @date 2021/1/29
 */
public class ConcreteVisitor2 implements Visitor {

    @Override
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName() + "被"
                + this.getClass().getSimpleName() + "访问");
        concreteElementA.operationA();
    }

    @Override
    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
        System.out.println(concreteElementB.getClass().getSimpleName() + "被"
                + this.getClass().getSimpleName() + "访问");
        concreteElementB.operationB();
    }
}

Element，定义一个accept操作，它以一个访问者为参数

/**
 * @author ctl
 * @date 2021/1/29
 */
public interface Element {

    void Accept(Visitor visitor);
}

ConcreteElementA，具体元素，实现accept操作

/**
 * @author ctl
 * @date 2021/1/29
 */
public class ConcreteElementA implements Element {

    // 处分利用双分派技术，实现处理于数据结构的分离
    @Override
    public void Accept(Visitor visitor) {
        visitor.visitConcreteElementA(this);
    }

    // 其他的相关方法
    public void operationA() {
        System.out.println("com.example.design.behavior.visitor.ConcreteElementA.operationA被调用");
    }
}

ConcreteElementB，具体元素，实现accept操作

/**
 * @author ctl
 * @date 2021/1/29
 */
public class ConcreteElementB implements Element {

    @Override
    public void Accept(Visitor visitor) {
        visitor.visitConcreteElementB(this);
    }

    public void operationB() {
        System.out.println("com.example.design.behavior.visitor.ConcreteElementB.operationB被调用");
    }
}

ObjectStructure 结构对象角色，这是使用访问者模式必备的角色，能枚举它的元素，可以提供一个高层接口以允许访问者访问它的元素。

/**
 * @author ctl
 * @date 2021/1/29
 */
public class ObjectStructure {

    private List<Element> elements = new ArrayList<>();

    public void attach(Element element) {
        elements.add(element);
    }

    public void detach(Element element) {
        elements.remove(element);
    }

    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.Accept(visitor);
        }
    }
}

测试类

/**
 * @author ctl
 * @date 2021/1/29
 */
public class VisitorMain {

    public static void main(String[] args) {
        ObjectStructure o = new ObjectStructure();
        o.attach(new ConcreteElementA());
        o.attach(new ConcreteElementB());

        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();

        o.accept(v1);
        o.accept(v2);
    }
}