访问者模式：对象结构的操作专家🚶‍♂️，分离算法与数据的完美方案！

---

---

前言：为什么需要访问者模式？🤔

各位宝子们，今天我们来聊一个设计模式界的"操作分离大师"——访问者模式！😎 还在为如何在不修改对象结构的情况下定义新操作而头疼吗？还在为复杂对象结构的多种操作而烦恼吗？访问者模式来拯救你啦！

访问者模式是设计模式家族中的"行为型专家"，它能帮我们优雅地将算法与对象结构分离，让我们可以在不改变元素类的前提下定义作用于这些元素的新操作。今天就带大家彻底搞懂这个"看似复杂，实则强大"的设计模式！💯

---

一、访问者模式：算法与数据分离的专家 🎭

1.1 什么是访问者模式？

访问者模式（Visitor Pattern）是一种行为型设计模式，它表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。就像现实生活中的访问者一样，他们可以对不同的地方执行不同的操作，而不需要改变这些地方本身！🏠

1.2 为什么需要访问者模式？

想象一下这些场景：

• 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作
• 需要根据对象的具体类型来执行不同的操作
• 对象结构包含很多类型的对象，希望对这些对象实施一些依赖其具体类型的操作
• 需要在不修改现有类的情况下增加新的操作

这些场景有什么共同点？它们都涉及到操作与对象结构的分离问题。访问者模式就是为这些场景量身定制的！🚀

---

二、访问者模式的结构与实现 🧩

2.1 访问者模式的核心结构

访问者模式包含以下几个关键角色：

• 抽象访问者（Visitor）：定义对每个具体元素的访问操作
• 具体访问者（ConcreteVisitor）：实现对每个具体元素的具体访问操作
• 抽象元素（Element）：定义接受访问者的接口
• 具体元素（ConcreteElement）：实现接受访问者的具体操作
• 对象结构（ObjectStructure）：包含元素的容器，提供遍历元素的方法

// 抽象访问者
public interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

// 具体访问者A
public class ConcreteVisitorA implements Visitor {
    @Override
    public void visit(ConcreteElementA elementA) {
        System.out.println("ConcreteVisitorA 访问 " + elementA.getClass().getSimpleName());
        System.out.println("对ElementA执行操作A");
    }
    
    @Override
    public void visit(ConcreteElementB elementB) {
        System.out.println("ConcreteVisitorA 访问 " + elementB.getClass().getSimpleName());
        System.out.println("对ElementB执行操作A");
    }
}

// 具体访问者B
public class ConcreteVisitorB implements Visitor {
    @Override
    public void visit(ConcreteElementA elementA) {
        System.out.println("ConcreteVisitorB 访问 " + elementA.getClass().getSimpleName());
        System.out.println("对ElementA执行操作B");
    }
    
    @Override
    public void visit(ConcreteElementB elementB) {
        System.out.println("ConcreteVisitorB 访问 " + elementB.getClass().getSimpleName());
        System.out.println("对ElementB执行操作B");
    }
}

// 抽象元素
public interface Element {
    void accept(Visitor visitor);
}

// 具体元素A
public class ConcreteElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    public String getSpecificMethodA() {
        return "ElementA的特有方法";
    }
}

// 具体元素B
public class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    
    public String getSpecificMethodB() {
        return "ElementB的特有方法";
    }
}

// 对象结构
public class ObjectStructure {
    private List<Element> elements = new ArrayList<>();
    
    public void addElement(Element element) {
        elements.add(element);
    }
    
    public void removeElement(Element element) {
        elements.remove(element);
    }
    
    public void accept(Visitor visitor) {
        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

2.2 使用示例

public class VisitorPatternDemo {
    public static void main(String[] args) {
        // 创建对象结构
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.addElement(new ConcreteElementA());
        objectStructure.addElement(new ConcreteElementB());
        objectStructure.addElement(new ConcreteElementA());
        
        // 创建访问者
        Visitor visitorA = new ConcreteVisitorA();
        Visitor visitorB = new ConcreteVisitorB();
        
        System.out.println("=== 访问者A的操作 ===");
        objectStructure.accept(visitorA);
        
        System.out.println("\n=== 访问者B的操作 ===");
        objectStructure.accept(visitorB);
    }
}

输出结果：

=== 访问者A的操作 ===
ConcreteVisitorA 访问 ConcreteElementA
对ElementA执行操作A
ConcreteVisitorA 访问 ConcreteElementB
对ElementB执行操作A
ConcreteVisitorA 访问 ConcreteElementA
对ElementA执行操作A

=== 访问者B的操作 ===
ConcreteVisitorB 访问 ConcreteElementA
对ElementA执行操作B
ConcreteVisitorB 访问 ConcreteElementB
对ElementB执行操作B
ConcreteVisitorB 访问 ConcreteElementA
对ElementA执行操作B

---

三、实战案例：文件系统操作 📁

让我们通过一个文件系统的例子来深入理解访问者模式：

// 抽象文件系统元素
public abstract class FileSystemElement {
    protected String name;
    
    public FileSystemElement(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    // 接受访问者
    public abstract void accept(FileSystemVisitor visitor);
}

// 文件类
public class File extends FileSystemElement {
    private long size;
    private String extension;
    
    public File(String name, long size, String extension) {
        super(name);
        this.size = size;
        this.extension = extension;
    }
    
    public long getSize() {
        return size;
    }
    
    public String getExtension() {
        return extension;
    }
    
    @Override
    public void accept(FileSystemVisitor visitor) {
        visitor.visit(this);
    }
}

// 目录类
public class Directory extends FileSystemElement {
    private List<FileSystemElement> children = new ArrayList<>();
    
    public Directory(String name) {
        super(name);
    }
    
    public void addChild(FileSystemElement element) {
        children.add(element);
    }
    
    public List<FileSystemElement> getChildren() {
        return children;
    }
    
    @Override
    public void accept(FileSystemVisitor visitor) {
        visitor.visit(this);
        // 递归访问子元素
        for (FileSystemElement child : children) {
            child.accept(visitor);
        }
    }
}

// 抽象文件系统访问者
public interface FileSystemVisitor {
    void visit(File file);
    void visit(Directory directory);
}

// 大小计算访问者
public class SizeCalculatorVisitor implements FileSystemVisitor {
    private long totalSize = 0;
    private int fileCount = 0;
    private int directoryCount = 0;
    
    @Override
    public void visit(File file) {
        totalSize += file.getSize();
        fileCount++;
        System.out.println("文件: " + file.getName() + " (" + file.getSize() + " bytes)");
    }
    
    @Override
    public void visit(Directory directory) {
        directoryCount++;
        System.out.println("目录: " + directory.getName() + "/");
    }
    
    public void printStatistics() {
        System.out.println("\n=== 统计信息 ===");
        System.out.println("总大小: " + totalSize + " bytes");
        System.out.println("文件数量: " + fileCount);
        System.out.println("目录数量: " + directoryCount);
    }
}

// 搜索访问者
public class SearchVisitor implements FileSystemVisitor {
    private String searchPattern;
    private List<FileSystemElement> results = new ArrayList<>();
    
    public SearchVisitor(String searchPattern) {
        this.searchPattern = searchPattern.toLowerCase();
    }
    
    @Override
    public void visit(File file) {
        if (file.getName().toLowerCase().contains(searchPattern)) {
            results.add(file);
            System.out.println("找到文件: " + file.getName());
        }
    }
    
    @Override
    public void visit(Directory directory) {
        if (directory.getName().toLowerCase().contains(searchPattern)) {
            results.add(directory);
            System.out.println("找到目录: " + directory.getName() + "/");
        }
    }
    
    public List<FileSystemElement> getResults() {
        return results;
    }
}

// 备份访问者
public class BackupVisitor implements FileSystemVisitor {
    private String backupPath;
    private List<String> backupLog = new ArrayList<>();
    
    public BackupVisitor(String backupPath) {
        this.backupPath = backupPath;
    }
    
    @Override
    public void visit(File file) {
        String backupFile = backupPath + "/" + file.getName();
        backupLog.add("备份文件: " + file.getName() + " -> " + backupFile);
        System.out.println("备份文件: " + file.getName() + " (" + file.getSize() + " bytes)");
    }
    
    @Override
    public void visit(Directory directory) {
        String backupDir = backupPath + "/" + directory.getName();
        backupLog.add("创建备份目录: " + backupDir);
        System.out.println("创建备份目录: " + directory.getName() + "/");
    }
    
    public void printBackupLog() {
        System.out.println("\n=== 备份日志 ===");
        for (String log : backupLog) {
            System.out.println(log);
        }
    }
}

// 权限检查访问者
public class PermissionCheckVisitor implements FileSystemVisitor {
    private List<String> issues = new ArrayList<>();
    
    @Override
    public void visit(File file) {
        // 模拟权限检查
        if (file.getName().endsWith(".exe") || file.getName().endsWith(".bat")) {
            issues.add("安全警告: 可执行文件 " + file.getName());
            System.out.println("⚠️ 安全警告: 可执行文件 " + file.getName());
        } else {
            System.out.println("✅ 文件安全: " + file.getName());
        }
    }
    
    @Override
    public void visit(Directory directory) {
        // 检查目录权限
        if (directory.getName().startsWith(".")) {
            issues.add("隐藏目录: " + directory.getName());
            System.out.println("🔍 隐藏目录: " + directory.getName() + "/");
        } else {
            System.out.println("📁 普通目录: " + directory.getName() + "/");
        }
    }
    
    public void printSecurityReport() {
        System.out.println("\n=== 安全报告 ===");
        if (issues.isEmpty()) {
            System.out.println("未发现安全问题");
        } else {
            for (String issue : issues) {
                System.out.println(issue);
            }
        }
    }
}

3.1 使用示例

public class FileSystemDemo {
    public static void main(String[] args) {
        // 构建文件系统结构
        Directory root = new Directory("root");
        
        Directory documents = new Directory("documents");
        documents.addChild(new File("report.pdf", 1024000, "pdf"));
        documents.addChild(new File("presentation.pptx", 2048000, "pptx"));
        
        Directory photos = new Directory("photos");
        photos.addChild(new File("vacation.jpg", 512000, "jpg"));
        photos.addChild(new File("family.png", 256000, "png"));
        
        Directory system = new Directory(".system");
        system.addChild(new File("config.txt", 1024, "txt"));
        system.addChild(new File("startup.bat", 512, "bat"));
        
        root.addChild(documents);
        root.addChild(photos);
        root.addChild(system);
        root.addChild(new File("readme.txt", 2048, "txt"));
        
        // 1. 计算大小
        System.out.println("=== 大小计算 ===");
        SizeCalculatorVisitor sizeVisitor = new SizeCalculatorVisitor();
        root.accept(sizeVisitor);
        sizeVisitor.printStatistics();
        
        // 2. 搜索文件
        System.out.println("\n=== 搜索 'photo' ===");
        SearchVisitor searchVisitor = new SearchVisitor("photo");
        root.accept(searchVisitor);
        
        // 3. 备份操作
        System.out.println("\n=== 备份操作 ===");
        BackupVisitor backupVisitor = new BackupVisitor("/backup");
        root.accept(backupVisitor);
        backupVisitor.printBackupLog();
        
        // 4. 权限检查
        System.out.println("\n=== 权限检查 ===");
        PermissionCheckVisitor permissionVisitor = new PermissionCheckVisitor();
        root.accept(permissionVisitor);
        permissionVisitor.printSecurityReport();
    }
}

---

四、实战案例：编译器AST处理 🌳

再来看一个编译器抽象语法树（AST）处理的例子：

// 抽象AST节点
public abstract class ASTNode {
    public abstract void accept(ASTVisitor visitor);
}

// 数字节点
public class NumberNode extends ASTNode {
    private double value;
    
    public NumberNode(double value) {
        this.value = value;
    }
    
    public double getValue() {
        return value;
    }
    
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// 变量节点
public class VariableNode extends ASTNode {
    private String name;
    
    public VariableNode(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// 二元操作节点
public class BinaryOpNode extends ASTNode {
    private ASTNode left;
    private ASTNode right;
    private String operator;
    
    public BinaryOpNode(ASTNode left, String operator, ASTNode right) {
        this.left = left;
        this.operator = operator;
        this.right = right;
    }
    
    public ASTNode getLeft() { return left; }
    public ASTNode getRight() { return right; }
    public String getOperator() { return operator; }
    
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// 函数调用节点
public class FunctionCallNode extends ASTNode {
    private String functionName;
    private List<ASTNode> arguments;
    
    public FunctionCallNode(String functionName, List<ASTNode> arguments) {
        this.functionName = functionName;
        this.arguments = arguments;
    }
    
    public String getFunctionName() { return functionName; }
    public List<ASTNode> getArguments() { return arguments; }
    
    @Override
    public void accept(ASTVisitor visitor) {
        visitor.visit(this);
    }
}

// AST访问者接口
public interface ASTVisitor {
    void visit(NumberNode node);
    void visit(VariableNode node);
    void visit(BinaryOpNode node);
    void visit(FunctionCallNode node);
}

// 表达式求值访问者
public class EvaluatorVisitor implements ASTVisitor {
    private Map<String, Double> variables = new HashMap<>();
    private Stack<Double> stack = new Stack<>();
    
    public EvaluatorVisitor() {
        // 初始化一些变量
        variables.put("x", 10.0);
        variables.put("y", 5.0);
        variables.put("pi", Math.PI);
    }
    
    @Override
    public void visit(NumberNode node) {
        stack.push(node.getValue());
        System.out.println("数字: " + node.getValue());
    }
    
    @Override
    public void visit(VariableNode node) {
        Double value = variables.get(node.getName());
        if (value != null) {
            stack.push(value);
            System.out.println("变量 " + node.getName() + " = " + value);
        } else {
            throw new RuntimeException("未定义的变量: " + node.getName());
        }
    }
    
    @Override
    public void visit(BinaryOpNode node) {
        // 先访问子节点
        node.getLeft().accept(this);
        node.getRight().accept(this);
        
        // 从栈中取出操作数
        double right = stack.pop();
        double left = stack.pop();
        double result;
        
        switch (node.getOperator()) {
            case "+":
                result = left + right;
                break;
            case "-":
                result = left - right;
                break;
            case "*":
                result = left * right;
                break;
            case "/":
                result = left / right;
                break;
            default:
                throw new RuntimeException("不支持的操作符: " + node.getOperator());
        }
        
        stack.push(result);
        System.out.println("计算: " + left + " " + node.getOperator() + " " + right + " = " + result);
    }
    
    @Override
    public void visit(FunctionCallNode node) {
        System.out.println("函数调用: " + node.getFunctionName());
        
        // 计算参数
        List<Double> args = new ArrayList<>();
        for (ASTNode arg : node.getArguments()) {
            arg.accept(this);
            args.add(stack.pop());
        }
        
        // 执行函数
        double result;
        switch (node.getFunctionName()) {
            case "sin":
                result = Math.sin(args.get(0));
                break;
            case "cos":
                result = Math.cos(args.get(0));
                break;
            case "sqrt":
                result = Math.sqrt(args.get(0));
                break;
            case "max":
                result = Math.max(args.get(0), args.get(1));
                break;
            default:
                throw new RuntimeException("不支持的函数: " + node.getFunctionName());
        }
        
        stack.push(result);
        System.out.println("函数结果: " + result);
    }
    
    public double getResult() {
        return stack.isEmpty() ? 0 : stack.peek();
    }
}

// 代码生成访问者
public class CodeGeneratorVisitor implements ASTVisitor {
    private StringBuilder code = new StringBuilder();
    private int indentLevel = 0;
    
    @Override
    public void visit(NumberNode node) {
        code.append(node.getValue());
    }
    
    @Override
    public void visit(VariableNode node) {
        code.append(node.getName());
    }
    
    @Override
    public void visit(BinaryOpNode node) {
        code.append("(");
        node.getLeft().accept(this);
        code.append(" ").append(node.getOperator()).append(" ");
        node.getRight().accept(this);
        code.append(")");
    }
    
    @Override
    public void visit(FunctionCallNode node) {
        code.append(node.getFunctionName()).append("(");
        for (int i = 0; i < node.getArguments().size(); i++) {
            if (i > 0) code.append(", ");
            node.getArguments().get(i).accept(this);
        }
        code.append(")");
    }
    
    public String getGeneratedCode() {
        return code.toString();
    }
}

// 语法检查访问者
public class SyntaxCheckerVisitor implements ASTVisitor {
    private List<String> errors = new ArrayList<>();
    private Set<String> definedVariables = new HashSet<>();
    
    public SyntaxCheckerVisitor() {
        // 预定义变量
        definedVariables.add("x");
        definedVariables.add("y");
        definedVariables.add("pi");
    }
    
    @Override
    public void visit(NumberNode node) {
        // 数字节点无需检查
        System.out.println("✅ 数字节点: " + node.getValue());
    }
    
    @Override
    public void visit(VariableNode node) {
        if (!definedVariables.contains(node.getName())) {
            errors.add("未定义的变量: " + node.getName());
            System.out.println("❌ 未定义的变量: " + node.getName());
        } else {
            System.out.println("✅ 变量: " + node.getName());
        }
    }
    
    @Override
    public void visit(BinaryOpNode node) {
        System.out.println("✅ 二元操作: " + node.getOperator());
        node.getLeft().accept(this);
        node.getRight().accept(this);
    }
    
    @Override
    public void visit(FunctionCallNode node) {
        Set<String> supportedFunctions = Set.of("sin", "cos", "sqrt", "max");
        if (!supportedFunctions.contains(node.getFunctionName())) {
            errors.add("不支持的函数: " + node.getFunctionName());
            System.out.println("❌ 不支持的函数: " + node.getFunctionName());
        } else {
            System.out.println("✅ 函数调用: " + node.getFunctionName());
        }
        
        for (ASTNode arg : node.getArguments()) {
            arg.accept(this);
        }
    }
    
    public boolean hasErrors() {
        return !errors.isEmpty();
    }
    
    public List<String> getErrors() {
        return errors;
    }
}

4.1 使用示例

public class ASTDemo {
    public static void main(String[] args) {
        // 构建AST: max(x + y, sin(pi))
        ASTNode ast = new FunctionCallNode("max", Arrays.asList(
            new BinaryOpNode(
                new VariableNode("x"),
                "+",
                new VariableNode("y")
            ),
            new FunctionCallNode("sin", Arrays.asList(
                new VariableNode("pi")
            ))
        ));
        
        // 1. 语法检查
        System.out.println("=== 语法检查 ===");
        SyntaxCheckerVisitor syntaxChecker = new SyntaxCheckerVisitor();
        ast.accept(syntaxChecker);
        
        if (syntaxChecker.hasErrors()) {
            System.out.println("语法错误:");
            for (String error : syntaxChecker.getErrors()) {
                System.out.println("- " + error);
            }
            return;
        }
        
        // 2. 代码生成
        System.out.println("\n=== 代码生成 ===");
        CodeGeneratorVisitor codeGenerator = new CodeGeneratorVisitor();
        ast.accept(codeGenerator);
        System.out.println("生成的代码: " + codeGenerator.getGeneratedCode());
        
        // 3. 表达式求值
        System.out.println("\n=== 表达式求值 ===");
        EvaluatorVisitor evaluator = new EvaluatorVisitor();
        ast.accept(evaluator);
        System.out.println("\n最终结果: " + evaluator.getResult());
    }
}

---

五、访问者模式的优缺点 ⚖️

5.1 优点 ✅

1. 符合单一职责原则：每个访问者负责一种操作
2. 优秀的扩展性：增加新操作很容易，只需添加新的访问者
3. 符合开闭原则：对扩展开放，对修改关闭
4. 数据结构与算法分离：访问者模式将数据结构与作用于结构上的操作解耦
5. 灵活性：可以在运行时决定使用哪个访问者

5.2 缺点 ❌

1. 增加新的元素类困难：需要修改所有访问者接口
2. 违反依赖倒置原则：访问者依赖于具体元素类
3. 破坏封装性：访问者可能需要访问元素的内部状态
4. 复杂性增加：引入了额外的抽象层次
5. 元素类暴露细节：元素类可能需要提供更多的公共方法

---

六、访问者模式 vs 其他模式 🆚

6.1 访问者 vs 策略模式

特性	访问者模式	策略模式
目的	在不修改元素类的前提下定义新操作	定义算法族，运行时选择算法
结构	双分派机制	简单的策略接口
适用场景	对象结构稳定，操作多变	算法多变，上下文稳定
扩展性	易于添加新操作，难以添加新元素	易于添加新算法

6.2 访问者 vs 命令模式

特性	访问者模式	命令模式
目的	分离算法与数据结构	将请求封装为对象
关注点	对不同类型对象的操作	请求的参数化和队列化
使用场景	复杂对象结构的多种操作	操作的撤销、重做、日志

---

七、使用场景与最佳实践 🎯

7.1 适用场景

1. 编译器设计

   • AST节点处理
   • 语法分析
   • 代码生成

2. 文档处理系统

   • 不同格式的文档元素
   • 渲染、导出、验证操作

3. 图形系统

   • 几何图形的绘制、计算、变换

4. 数据结构遍历

   • 树形结构的多种操作
   • 图的遍历算法

7.2 最佳实践

1. 使用双分派机制：

// 元素类中的accept方法
public void accept(Visitor visitor) {
    visitor.visit(this); // 将具体类型传递给访问者
}

2. 考虑使用泛型：

public interface Visitor<T> {
    T visit(ConcreteElementA elementA);
    T visit(ConcreteElementB elementB);
}

3. 提供默认实现：

public abstract class AbstractVisitor implements Visitor {
    @Override
    public void visit(ConcreteElementA elementA) {
        // 默认实现
    }
    
    @Override
    public void visit(ConcreteElementB elementB) {
        // 默认实现
    }
}

4. 使用访问者工厂：

public class VisitorFactory {
    public static Visitor createVisitor(String type) {
        switch (type) {
            case "size": return new SizeCalculatorVisitor();
            case "search": return new SearchVisitor("");
            case "backup": return new BackupVisitor("/backup");
            default: throw new IllegalArgumentException("Unknown visitor type");
        }
    }
}

---

八、Java标准库中的访问者模式 ☕

Java标准库中也有访问者模式的应用：

8.1 NIO.2 文件访问

// Java NIO.2中的FileVisitor
Files.walkFileTree(Paths.get("/some/path"), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        System.out.println("访问文件: " + file);
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        System.out.println("进入目录: " + dir);
        return FileVisitResult.CONTINUE;
    }
});

8.2 XML处理

// DOM树的访问者模式应用
public class XMLVisitor {
    public void visit(Document document) {
        visit(document.getDocumentElement());
    }
    
    public void visit(Element element) {
        System.out.println("元素: " + element.getTagName());
        NodeList children = element.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node child = children.item(i);
            if (child instanceof Element) {
                visit((Element) child);
            } else if (child instanceof Text) {
                visit((Text) child);
            }
        }
    }
    
    public void visit(Text text) {
        String content = text.getTextContent().trim();
        if (!content.isEmpty()) {
            System.out.println("文本: " + content);
        }
    }
}

---

总结：访问者模式的精髓 🎉

访问者模式是一个强大但复杂的设计模式，它的核心思想是：

1. 分离关注点：将算法与数据结构分离
2. 双分派机制：通过两次方法调用确定具体操作
3. 开闭原则：易于添加新操作，但难以添加新元素
4. 单一职责：每个访问者负责一种特定操作

记住这个口诀："数据结构要稳定，操作多变用访问者，双分派来定类型，算法数据要分离！"🎯

访问者模式特别适合于对象结构相对稳定，但需要经常添加新操作的场景。在编译器、文档处理、图形系统等领域有广泛应用。各位宝子们，在合适的场景下使用访问者模式，能让你的代码更加灵活和可维护！💪

---

希望这篇文章能帮助大家更好地理解和应用访问者模式！如果觉得有用，记得点赞收藏哦！ 😊