访问者模式

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"
    }
}

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

相关推荐
苹果醋36 分钟前
React源码02 - 基础知识 React API 一览
java·运维·spring boot·mysql·nginx
晓纪同学22 分钟前
QT-简单视觉框架代码
开发语言·qt
威桑22 分钟前
Qt SizePolicy详解：minimum 与 minimumExpanding 的区别
开发语言·qt·扩张策略
Hello.Reader25 分钟前
深入解析 Apache APISIX
java·apache
飞飞-躺着更舒服25 分钟前
【QT】实现电子飞行显示器（简易版）
开发语言·qt
明月看潮生31 分钟前
青少年编程与数学 02-004 Go语言Web编程 16课题、并发编程
开发语言·青少年编程·并发编程·编程与数学·goweb
明月看潮生34 分钟前
青少年编程与数学 02-004 Go语言Web编程 17课题、静态文件
开发语言·青少年编程·编程与数学·goweb
Java Fans37 分钟前
C# 中串口读取问题及解决方案
开发语言·c#
盛派网络小助手1 小时前
微信 SDK 更新 Sample，NCF 文档和模板更新，更多更新日志，欢迎解锁
开发语言·人工智能·后端·架构·c#
菠萝蚊鸭1 小时前
Dhatim FastExcel 读写 Excel 文件
java·excel·fastexcel
热门推荐
01Cube-Studio：开源大模型全链路一站式中台02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07构建高效的广告投放系统：应用架构的设计与实现08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10【一文读懂】NTN（非地面网络）技术介绍