访问者模式

// Visitor接口
public interface DocumentVisitor {
    void visit(Article article);
    void visit(Image image);
    void visit(Table table);
}

// ConcreteVisitor1类（打印文档）
public class PrintVisitor implements DocumentVisitor {
    @Override
    public void visit(Article article) {
        System.out.println("打印文章: " + article.getContent());
    }

    @Override
    public void visit(Image image) {
        System.out.println("打印图片: " + image.getPath());
    }

    @Override
    public void visit(Table table) {
        System.out.println("打印表格: " + table.getContent());
    }
}

// ConcreteVisitor2类（统计元素数量）
public class CountVisitor implements DocumentVisitor {
    private int articleCount = 0;
    private int imageCount = 0;
    private int tableCount = 0;

    @Override
    public void visit(Article article) {
        articleCount++;
    }

    @Override
    public void visit(Image image) {
        imageCount++;
    }

    @Override
    public void visit(Table table) {
        tableCount++;
    }

    public void report() {
        System.out.println("文章数量: " + articleCount);
        System.out.println("图片数量: " + imageCount);
        System.out.println("表格数量: " + tableCount);
    }
}

// Element接口
public interface DocumentElement {
    void accept(DocumentVisitor visitor);
}

// ConcreteElementA类（文章）
public class Article implements DocumentElement {
    private String content;

    public Article(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

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

// ConcreteElementB类（图片）
public class Image implements DocumentElement {
    private String path;

    public Image(String path) {
        this.path = path;
    }

    public String getPath() {
        return path;
    }

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

// ConcreteElementC类（表格）
public class Table implements DocumentElement {
    private String content;

    public Table(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

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

// Client类
import java.util.ArrayList;
import java.util.List;

public class VisitorPatternDemo {
    public static void main(String[] args) {
        List<DocumentElement> document = new ArrayList<>();
        document.add(new Article("访问者模式简介"));
        document.add(new Image("/images/visitor.png"));
        document.add(new Table("元素统计表"));
        document.add(new Article("访问者模式的实现"));
        document.add(new Image("/images/visitor2.png"));

        // 使用PrintVisitor打印文档
        DocumentVisitor printVisitor = new PrintVisitor();
        System.out.println("=== 打印文档 ===");
        for (DocumentElement element : document) {
            element.accept(printVisitor);
        }

        // 使用CountVisitor统计元素数量
        CountVisitor countVisitor = new CountVisitor();
        for (DocumentElement element : document) {
            element.accept(countVisitor);
        }
        System.out.println("
=== 元素统计 ===");
        countVisitor.report();
    }
}

// Visitor接口
public interface ASTVisitor {
    void visit(BinaryExpression expr);
    void visit(LiteralExpression expr);
    void visit(VariableExpression expr);
}

// ConcreteVisitor1类（类型检查）
public class TypeCheckVisitor implements ASTVisitor {
    @Override
    public void visit(BinaryExpression expr) {
        expr.getLeft().accept(this);
        expr.getRight().accept(this);
        // 类型检查逻辑
        System.out.println("类型检查 BinaryExpression");
    }

    @Override
    public void visit(LiteralExpression expr) {
        // 类型检查逻辑
        System.out.println("类型检查 LiteralExpression");
    }

    @Override
    public void visit(VariableExpression expr) {
        // 类型检查逻辑
        System.out.println("类型检查 VariableExpression");
    }
}

// ConcreteVisitor2类（代码生成）
public class CodeGenerationVisitor implements ASTVisitor {
    @Override
    public void visit(BinaryExpression expr) {
        expr.getLeft().accept(this);
        expr.getRight().accept(this);
        // 代码生成逻辑
        System.out.println("生成代码 BinaryExpression");
    }

    @Override
    public void visit(LiteralExpression expr) {
        // 代码生成逻辑
        System.out.println("生成代码 LiteralExpression");
    }

    @Override
    public void visit(VariableExpression expr) {
        // 代码生成逻辑
        System.out.println("生成代码 VariableExpression");
    }
}

// Element接口
public interface ASTNode {
    void accept(ASTVisitor visitor);
}

// ConcreteElementA类（BinaryExpression）
public class BinaryExpression implements ASTNode {
    private ASTNode left;
    private ASTNode right;

    public BinaryExpression(ASTNode left, ASTNode right){
        this.left = left;
        this.right = right;
    }

    public ASTNode getLeft() {
        return left;
    }

    public ASTNode getRight() {
        return right;
    }

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

// ConcreteElementB类（LiteralExpression）
public class LiteralExpression implements ASTNode {
    private Object value;

    public LiteralExpression(Object value){
        this.value = value;
    }

    public Object getValue() {
        return value;
    }

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

// ConcreteElementC类（VariableExpression）
public class VariableExpression implements ASTNode {
    private String name;

    public VariableExpression(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

// Client类
public class VisitorPatternCompilerDemo {
    public static void main(String[] args) {
        // 构建语法树: (x + 5)
        ASTNode expression = new BinaryExpression(
            new VariableExpression("x"),
            new LiteralExpression(5)
        );

        // 类型检查
        ASTVisitor typeChecker = new TypeCheckVisitor();
        System.out.println("
=== 类型检查 ===");
        expression.accept(typeChecker);

        // 代码生成
        ASTVisitor codeGenerator = new CodeGenerationVisitor();
        System.out.println("
=== 代码生成 ===");
        expression.accept(codeGenerator);
    }
}

// Visitor接口
public interface ReportVisitor {
    void visit(SummaryReport report);
    void visit(DetailedReport report);
}

// ConcreteVisitor1类（PDF报告生成）
public class PDFReportVisitor implements ReportVisitor {
    @Override
    public void visit(SummaryReport report) {
        System.out.println("生成PDF格式的总结报告。");
        // 具体的PDF生成逻辑
    }

    @Override
    public void visit(DetailedReport report) {
        System.out.println("生成PDF格式的详细报告。");
        // 具体的PDF生成逻辑
    }
}

// ConcreteVisitor2类（HTML报告生成）
public class HTMLReportVisitor implements ReportVisitor {
    @Override
    public void visit(SummaryReport report) {
        System.out.println("生成HTML格式的总结报告。");
        // 具体的HTML生成逻辑
    }

    @Override
    public void visit(DetailedReport report) {
        System.out.println("生成HTML格式的详细报告。");
        // 具体的HTML生成逻辑
    }
}

// Element接口
public interface Report {
    void accept(ReportVisitor visitor);
}

// ConcreteElementA类（总结报告）
public class SummaryReport implements Report {
    @Override
    public void accept(ReportVisitor visitor) {
        visitor.visit(this);
    }
}

// ConcreteElementB类（详细报告）
public class DetailedReport implements Report {
    @Override
    public void accept(ReportVisitor visitor) {
        visitor.visit(this);
    }
}

// Client类
import java.util.ArrayList;
import java.util.List;

public class VisitorPatternReportDemo {
    public static void main(String[] args) {
        List<Report> reports = new ArrayList<>();
        reports.add(new SummaryReport());
        reports.add(new DetailedReport());

        // 生成PDF报告
        ReportVisitor pdfVisitor = new PDFReportVisitor();
        System.out.println("
=== 生成PDF报告 ===");
        for (Report report : reports) {
            report.accept(pdfVisitor);
        }

        // 生成HTML报告
        ReportVisitor htmlVisitor = new HTMLReportVisitor();
        System.out.println("
=== 生成HTML报告 ===");
        for (Report report : reports) {
            report.accept(htmlVisitor);
        }
    }
}