访问者模式

DreamBoat_Onism2024-03-09 8:49

访问者模式（Visitor Pattern）是一种行为型设计模式，它用于在不改变元素类的前提下，为元素的不同操作（访问）提供不同的处理方式。访问者模式将数据结构与数据操作分离，使得可以在不修改数据结构的情况下添加新的操作或访问方式。

访问者模式的核心思想是引入一个访问者对象，该对象包含了一组访问操作，每个操作用于处理不同类型的元素。元素类会接受访问者对象，并将自身传递给访问者，让访问者根据元素的类型执行相应的操作。

结构

以下是访问者模式的主要角色：

  1. 访问者（Visitor）： 访问者是一个接口或抽象类，定义了一组访问操作，每个操作用于处理特定类型的元素。

  2. 具体访问者（Concrete Visitor）： 具体访问者是访问者的实现类，它实现了访问者接口中定义的访问操作，以定义不同类型元素的处理方式。

  3. 元素（Element）： 元素是一个接口或抽象类，定义了一个 accept 方法，该方法接受访问者对象，并将自身传递给访问者对象以进行处理。

  4. 具体元素（Concrete Element）： 具体元素是元素的实现类，它实现了 accept 方法，并将自身传递给访问者对象，以便访问者可以根据元素的类型执行相应的操作。

  5. 对象结构（Object Structure）： 对象结构是一个集合，它可以包含不同类型的元素。访问者将访问对象结构中的元素，执行相应的操作。

示例

通过一个 Java 示例来演示访问者模式。

在这个示例中，将创建一个基于访问者模式的简单计算器，用于执行不同的操作（加法、减法、乘法、除法）并计算结果。

首先定义访问者接口和元素接口：

java 复制代码 
// 访问者接口
interface Visitor {
    void visit(AdditionOperation operation);
    void visit(SubtractionOperation operation);
    void visit(MultiplicationOperation operation);
    void visit(DivisionOperation operation);
}

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

然后，实现具体的访问者类：

java 复制代码 
// 具体访问者类
class Calculator implements Visitor {
    @Override
    public void visit(AdditionOperation operation) {
        System.out.println(operation.getLeftOperand() + " + " + operation.getRightOperand() + " = " + (operation.getLeftOperand() + operation.getRightOperand()));
    }

    @Override
    public void visit(SubtractionOperation operation) {
        System.out.println(operation.getLeftOperand() + " - " + operation.getRightOperand() + " = " + (operation.getLeftOperand() - operation.getRightOperand()));
    }

    @Override
    public void visit(MultiplicationOperation operation) {
        System.out.println(operation.getLeftOperand() + " * " + operation.getRightOperand() + " = " + (operation.getLeftOperand() * operation.getRightOperand()));
    }

    @Override
    public void visit(DivisionOperation operation) {
        if (operation.getRightOperand() != 0) {
            System.out.println(operation.getLeftOperand() + " / " + operation.getRightOperand() + " = " + (operation.getLeftOperand() / operation.getRightOperand()));
        } else {
            System.out.println("除数不能为0");
        }
    }
}

接下来实现具体的元素类：

java 复制代码 
// 具体元素类 - 加法
class AdditionOperation implements Operation {
    private int leftOperand;
    private int rightOperand;

    public AdditionOperation(int leftOperand, int rightOperand) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
    }

    public int getLeftOperand() {
        return leftOperand;
    }

    public int getRightOperand() {
        return rightOperand;
    }

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

// 具体元素类 - 减法
class SubtractionOperation implements Operation {
    private int leftOperand;
    private int rightOperand;

    public SubtractionOperation(int leftOperand, int rightOperand) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
    }

    public int getLeftOperand() {
        return leftOperand;
    }

    public int getRightOperand() {
        return rightOperand;
    }

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

// 具体元素类 - 乘法
class MultiplicationOperation implements Operation {
    private int leftOperand;
    private int rightOperand;

    public MultiplicationOperation(int leftOperand, int rightOperand) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
    }

    public int getLeftOperand() {
        return leftOperand;
    }

    public int getRightOperand() {
        return rightOperand;
    }

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

// 具体元素类 - 除法
class DivisionOperation implements Operation {
    private int leftOperand;
    private int rightOperand;

    public DivisionOperation(int leftOperand, int rightOperand) {
        this.leftOperand = leftOperand;
        this.rightOperand = rightOperand;
    }

    public int getLeftOperand() {
        return leftOperand;
    }

    public int getRightOperand() {
        return rightOperand;
    }

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

最后，在主程序中使用访问者模式执行计算：

java 复制代码 
public class Client {
    public static void main(String[] args) {
        Operation addition = new AdditionOperation(5, 3);
        Operation subtraction = new SubtractionOperation(10, 4);
        Operation multiplication = new MultiplicationOperation(7, 2);
        Operation division = new DivisionOperation(8, 0); // Division by zero

        Visitor calculator = new Calculator();

        addition.accept(calculator);
        subtraction.accept(calculator);
        multiplication.accept(calculator);
        division.accept(calculator);
    }
}

在这个示例中，创建了四个不同的具体元素类（加法、减法、乘法、除法），并通过访问者模式来执行计算操作。计算器访问者类根据元素的类型执行相应的计算，并输出结果。

这种模式使得可以在不修改元素类的情况下，轻松地添加新的操作，从而提高了代码的可扩展性。

优点

访问者模式的优点包括：

  1. 增加新操作更容易： 在不修改元素类的情况下，可以通过添加新的访问者类来增加新的操作或功能。这符合开闭原则（Open-Closed Principle）。

  2. 相关操作集中化： 将与元素相关的操作集中在访问者中，使得代码更易于维护和理解。

  3. 解耦元素和操作： 访问者模式将元素类与操作类分离，减少了它们之间的耦合，使得系统更加灵活。

  4. 支持多态处理： 可以根据元素的实际类型动态选择访问者对象，从而支持多态处理。

缺点

然而，访问者模式也有一些缺点，包括：

  1. 增加了类的数量： 引入了访问者和具体访问者类，可能会增加类的数量，使得代码变得复杂。

  2. 不容易理解： 对于初学者来说，访问者模式可能不容易理解，因为它引入了额外的抽象层次。

  3. 不适用于简单场景： 在简单的情况下，访问者模式可能会显得过于复杂，不适合使用。

访问者模式通常在需要对一个复杂的对象结构进行多种不同操作（例如编译器、解析器、文档处理等）的情况下非常有用。它提供了一种灵活的方式来处理不同类型的元素，同时保持元素类的封装性。

拓展

访问者模式通常使用了一种双分派（Double Dispatch）的技术，它是该模式的核心概念之一。双分派指的是在运行时根据两个对象的类型来决定调用的方法，一种分派是根据访问者对象的类型，另一种分派是根据元素对象的类型。

在访问者模式中，具体的元素类（Concrete Element）实现了一个 accept 方法，该方法接受一个访问者对象（Visitor），然后在运行时根据元素对象的类型调用访问者对象中的特定方法。这是第一次分派，也就是根据元素对象的类型分派到不同的 visit 方法。

然后，在具体的访问者类（Concrete Visitor）中，根据自身的类型以及元素对象的类型来选择执行哪个操作。这是第二次分派，也就是根据访问者对象的类型再次分派到不同的操作。

这种双分派技术使得访问者模式能够实现根据元素对象类型和访问者对象类型来动态选择不同的操作，从而实现多态行为。这在处理复杂对象结构和多种操作时非常有用，因为可以根据不同的组合来执行不同的操作，而不需要使用大量的条件语句或类型检查。

双分派是一种在运行时动态确定调用的方法的技术，通常与多态性相关联。它有两种主要的变体：静态双分派和动态双分派。

  1. 静态双分派（Static Double Dispatch）： 静态双分派是指在编译时根据两个对象的类型来确定调用的方法。这种情况下，编译器会根据对象的静态类型（声明时的类型）来选择方法。静态双分派通常不支持多态性，因为它在编译时已经确定了调用的方法。Java 的方法重载就是一种静态双分派的例子。

    示例：

    java 复制代码 
    class StaticDispatchDemo {
    void process(Animal animal) {
        System.out.println("Animal is processed.");
    }

    void process(Dog dog) {
        System.out.println("Dog is processed.");
    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        StaticDispatchDemo dispatcher = new StaticDispatchDemo();
        dispatcher.process(animal); // 输出 "Animal is processed."
    }
}

  2. 动态双分派（Dynamic Double Dispatch）： 动态双分派是指在运行时根据两个对象的类型来确定调用的方法。这种情况下，编译器不提前确定方法，而是根据对象的动态类型（实际运行时的类型）来选择方法。动态双分派通常涉及到多态性，因为它允许在运行时根据实际对象的类型进行方法调用。

    访问者模式是动态双分派的一个典型示例。在访问者模式中，元素对象的类型和访问者对象的类型都可以在运行时确定，然后根据这两个类型来动态选择执行的方法。

    示例（访问者模式）：

    java 复制代码 
    interface Element {
    void accept(Visitor visitor);
}

interface Visitor {
    void visit(Element element);
}

class ConcreteElementA implements Element {
    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class ConcreteElementB implements Element {
    @Override
    void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class ConcreteVisitor1 implements Visitor {
    @Override
    void visit(Element element) {
        System.out.println("ConcreteVisitor1 is visiting " + element.getClass().getSimpleName());
    }
}

class ConcreteVisitor2 implements Visitor {
    @Override
    void visit(Element element) {
        System.out.println("ConcreteVisitor2 is visiting " + element.getClass().getSimpleName());
    }
}

public class DynamicDispatchDemo {
    public static void main(String[] args) {
        Element elementA = new ConcreteElementA();
        Element elementB = new ConcreteElementB();
        Visitor visitor1 = new ConcreteVisitor1();
        Visitor visitor2 = new ConcreteVisitor2();

        elementA.accept(visitor1); // 输出 "ConcreteVisitor1 is visiting ConcreteElementA"
        elementB.accept(visitor2); // 输出 "ConcreteVisitor2 is visiting ConcreteElementB"
    }
}

总的来说，双分派是一种在编程中处理多态性和方法调用的重要技术，它允许根据对象的动态类型来确定方法的调用，从而实现了灵活的行为分派。在某些情况下，动态双分派是访问者模式等模式的关键要素。

相关推荐
个 人 练 习 生5 分钟前
数据结构入门：算法复杂度
开发语言·数据结构·经验分享·学习·程序人生·算法
W_3260014 分钟前
Python-OpenCV边缘检测与阈值分割：Sobel、Scharr、Laplacian、Canny、全局与自适应阈值
开发语言·图像处理·python·opencv·机器学习
其实防守也摸鱼15 分钟前
红队技能总结导图：从入门到精通的完整知识体系
开发语言·人工智能·学习·安全·web安全
聊浮游25 分钟前
JAVA2026最新全套学习资料、学习路线
java·开发语言·jvm·mysql·spring·maven·idea
MacroZheng37 分钟前
完美替代 Navicat！这款内置 AI 的数据库工具，太香了！
java·后端·mysql
SamDeepThinking1 小时前
从REST到gRPC，一个API选型的思考框架
java·后端·程序员
Zane19941 小时前
接口都能写默认实现了，为什么还需要抽象类
java·后端
未秃头的程序猿1 小时前
读Spring AI源码的方法——不是硬啃，是带着问题去翻
java·后端·spring
不会代码的小猴1 小时前
4. 控件学习2
开发语言·c++·笔记·qt
用户3126874877201 小时前
别再 Thread.sleep 硬等了！并发工具类到底怎么选？
java
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点032026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？04微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新05Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费06历年考研数学一、数学二、数学三真题试卷及答案PDF07VSCode+CodeX扩展，无法启动08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法