java - 访问者模式用法-6ren

java - 访问者模式用法

转载作者：行者123 更新时间：2023-11-29 09:49:59

https://stackoverflow.com/questions/9239445/sample-of-using-visitor-patternbefore-and-after

我是否正确理解访问者模式的主要目的？据我了解:

1 之前

public class Main {

    public static void main(String[] args) {
        List<CompanyItem> items = new ArrayList<CompanyItem>();
        items.add(new Employee(10));
        items.add(new Employee(10.6));
        items.add(new Employee(15.9));
        items.add(new Manager(20.1));
        items.add(new Boss(30));

        double totalSalary = 0;
        for(CompanyItem i:items){
            if (i instanceof Employee) {
                totalSalary += ((Employee) i).getSalary();
            } else if (i instanceof Manager) {
                totalSalary += ((Manager) i).getSalary();
                totalSalary += ((Manager) i).getBonusses();
            }else if (i instanceof Boss) {
                totalSalary += ((Boss) i).getSalary();
                totalSalary += ((Boss) i).getAdditionalSalary();
            }
        }
        System.out.println(totalSalary);
    }

    interface CompanyItem {
    }

    static class Employee implements CompanyItem {
        double salary;

        public Employee(double salary) {
            this.salary = salary;
        }

        public double getSalary() {
            return salary;
        }
    }

    static class Manager implements CompanyItem {
        double salary, bonusses;

        public Manager(double salary) {
            this.salary = salary;
            this.bonusses = 1.5 * salary;
        }

        public double getSalary() {
            return  salary;
        }

        public double getBonusses() {
            return bonusses;
        }
    }

    static class Boss implements CompanyItem {
        double salary, addSalary;

        public Boss(double salary) {
            this.salary = salary;
            this.addSalary = 3 * salary;
        }

        public double getSalary() {
            return salary;
        }

        public double getAdditionalSalary() {
            return addSalary;
        }
    }
}

2 之前

public class Main3 {

    public static void main(String[] args) {
        List<CompanyItem> items = new ArrayList<CompanyItem>();
        items.add(new Employee(10));
        items.add(new Employee(10.6));
        items.add(new Employee(15.9));
        items.add(new Manager(20.1));
        items.add(new Boss(30));

        double totalSalary = 0;
        for(CompanyItem i:items){
            totalSalary+=i.getSalary();
            totalSalary+=i.getBonusses();
            totalSalary+=i.getAdditionalSalary();
        }
        System.out.println(totalSalary);
    }

    interface CompanyItem {
        public double getSalary();
        public double getBonusses();
        public double getAdditionalSalary();
    }

    static class Employee implements CompanyItem {
        double salary;

        public Employee(double salary) {
            this.salary = salary;
        }

        public double getSalary() {
            return salary;
        }

        @Override
        public double getBonusses() {
            return 0;
        }

        @Override
        public double getAdditionalSalary() {
            return 0;
        }
    }

    static class Manager implements CompanyItem {
        double salary, bonusses;

        public Manager(double salary) {
            this.salary = salary;
            this.bonusses = 1.5 * salary;
        }

        public double getSalary() {
            return  salary;
        }

        public double getBonusses() {
            return bonusses;
        }

        @Override
        public double getAdditionalSalary() {
            return 0;
        }
    }

    static class Boss implements CompanyItem {
        double salary, addSalary;

        public Boss(double salary) {
            this.salary = salary;
            this.addSalary = 3 * salary;
        }

        public double getSalary() {
            return salary;
        }

        public double getAdditionalSalary() {
            return addSalary;
        }

        @Override
        public double getBonusses() {
            return 0;
        }
    }
}

之后(使用访问者模式 ???)

public class Main1 {

    public static void main(String[] args) {
        List<CompanyItem> items = new ArrayList<CompanyItem>();
        items.add(new Employee(10));
        items.add(new Employee(10.6));
        items.add(new Employee(15.9));
        items.add(new Manager(20.1));
        items.add(new Boss(30));

        SalaryVisitor visitor = new SalaryVisitor();
        for(CompanyItem i:items){
            i.accept(visitor);
        }
        System.out.println(visitor.getTotalSalary());
    }

     interface CompanyItem {
        public void accept(Visitor v);
    }

    static class Employee implements CompanyItem {
        double salary;

        public Employee(double salary) {
            this.salary = salary;
        }

        public double getSalary() {
            return salary;
        }

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

    static class Manager implements CompanyItem {
        double salary,bonusses;

        public Manager(double salary) {
            this.salary = salary;
            this.bonusses = 1.5 * salary;
        }

        public double getSalary() {
            return  salary;
        }

        public double getBonusses(){
            return bonusses;
        }

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

    static class Boss implements CompanyItem {
        double salary, addSalary;

        public Boss(double salary) {
            this.salary = salary;
            this.addSalary = 3 * salary;
        }

        public double getSalary() {
            return  salary;
        }
        public double getAdditionalSalary(){
            return addSalary;
        }

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

    interface Visitor {
        public void visit(Employee e);
        public void visit(Manager m);
        public void visit(Boss b);
    }

    static class SalaryVisitor implements Visitor {
        double totalSalary;

        public SalaryVisitor() {
            totalSalary = 0;
        }

        public double getTotalSalary(){
            return totalSalary;
        }

        @Override
        public void visit(Employee e) {
            totalSalary += e.getSalary();           
        }

        @Override
        public void visit(Manager m) {
            totalSalary += (m.getSalary()+m.getBonusses()); 
        }

        @Override
        public void visit(Boss b) {
            totalSalary += (b.getSalary()+b.getAdditionalSalary()); 
        }
    }
}

我说得对吗？

最佳答案

从技术上讲，该示例很好地实现了访问者模式。但是这个例子并没有提升访问者的优势。要点是:如果您希望多个独立的算法在同一数据结构上工作 - 而无需更改数据结构，则实现访问者模式开销。

为了增强您的示例，我建议进行以下更改:将简单的奖金系统替换为一个系统，该系统在所有经理根据每个经理拥有的一些奖励积分。如果有两个经理，一个有 140 分，另一个有 60 分，那么第一个得到 70k$，第二个得到 30k$。

这允许您有多个访问者:

一个总结所有经理的所有奖励积分
一个使用上一步的总和在经理之间分配奖金 (100k$)。将这个计算出的个人奖金设置到 Manager
第三位访问者 (PaydayVisitor) 为员工、老板和经理打印支票，并返回所有已完成付款的总和。

编辑在代码中，这看起来像这样(仅为了简洁起见省略了 getter/setter):

import java.util.ArrayList;
import java.util.List;

public class VisitorExample {
    public static void main(String[] args) {
        List<CompanyItem> items = new ArrayList<CompanyItem>();
        items.add(new Employee(10));
        items.add(new Employee(10.6));
        items.add(new Employee(15.9));
        items.add(new Manager(20.1, 140));
        items.add(new Manager(42.1, 70));
        items.add(new Boss(30, 10));

        // sum up all bonus points of all Managers
        BonusPointVisitor bonusPointVisitor = new BonusPointVisitor();
        for(CompanyItem i: items)
            i.accept(bonusPointVisitor);

        // distribute given bonus sum among the managers
        BonusDistributorVisitor bonusDistributorVisitor = 
            new BonusDistributorVisitor(bonusPointVisitor.totalBonusPoints, 100.0);
        for(CompanyItem i: items)
            i.accept(bonusDistributorVisitor);

        // PayDay - print all checks
        PrintCheckVisitor printCheckVisitor = new PrintCheckVisitor();
        for(CompanyItem i: items)
            i.accept(printCheckVisitor);
        System.out.println("total money spent this month: "+printCheckVisitor.totalPayments);
    }

    interface CompanyItem {
        public void accept(Visitor v);
    }

    interface Visitor {
        public void visit(Employee e);
        public void visit(Manager m);
        public void visit(Boss b);
    }

    static class Employee implements CompanyItem {
        double salary;

        public Employee(double salary) {
            this.salary = salary;
        }

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

    static class Manager implements CompanyItem {
        double salary, bonusPoints, bonus;

        public Manager(double salary, double bonusPoints) {
            this.salary = salary;
            this.bonusPoints = bonusPoints;
            this.bonus = 0;
        }

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

    static class Boss implements CompanyItem {
        double salary, addSalary;

        public Boss(double salary, double addSalary) {
            this.salary = salary;
            this.addSalary = addSalary;
        }

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

    static class BonusPointVisitor implements Visitor {
        double totalBonusPoints = 0d;

        @Override
        public void visit(Employee e) {
        }

        @Override
        public void visit(Manager m) {
            totalBonusPoints += m.bonusPoints;
        }

        @Override
        public void visit(Boss b) {
        }
    }


    static class BonusDistributorVisitor  implements Visitor {
        double totalBonusPoints, totalBonus;

        public BonusDistributorVisitor(double totalBonusPoints, double totalBonus) {
            this.totalBonusPoints = totalBonusPoints;
            this.totalBonus = totalBonus;
        }

        @Override
        public void visit(Employee e) {
        }

        @Override
        public void visit(Manager m) {
            m.bonus = (m.bonusPoints / totalBonusPoints) * totalBonus;
        }

        @Override
        public void visit(Boss b) {
        }
    }

    static class PrintCheckVisitor implements Visitor {
        double totalPayments = 0;

        @Override
        public void visit(Employee e) {
            advisePayment(e.salary);
        }

        @Override
        public void visit(Manager m) {
            advisePayment(m.salary + m.bonus);
        }

        @Override
        public void visit(Boss b) {
            advisePayment(b.salary + b.addSalary);
        }

        private void advisePayment(double amount){
            System.out.println("pay "+amount+" credits");
            totalPayments += amount;
        }
    }
}

剩下要做的事情:给每个项目一些可打印的名称，以便在 advisePayment 中使用。

关于java - 访问者模式用法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9240551/

文章推荐： java - 使用 ArrayList 类型错误？

文章推荐： java - Android setText 导致崩溃

文章推荐： java - 我可以在构造函数之前调用方法吗

文章推荐： java while (scan.nextLine() != "$")

java - 如何正确实现 ANTLR4 访问者
我正在尝试为玩具语言实现一个解析器。我已经编写了语法，但是当我尝试从 CST 创建 AST 时遇到了问题。我定义了一个继承自 MyParserVisitor 的类哪里ASTNode是一个虚拟类，我
c++ - 多态、访问者、如何调用重载函数？
我想创建子类对象，它会与其他子类对象做出不同的 react (类可以欢迎另一个类，但不是全部)代码原理源自访客设计模式: class A { public : virtual bool isW
c++ - 通过自定义边缘权重惩罚来 boost A* 访问者？
我正在玩 boost A* 算法，从在以下位置找到的示例开始:http://www.boost.org/doc/libs/1_37_0/libs/graph/example/astar-cities.
php - MySQL 访问者/命中计数器排序统计
我正在为我的网站构建一个访问者和点击率计数器，当然，访问者每天是一个唯一的 ip，点击率是每次请求页面时! 我已经创建了数据库和系统来插入和更新我保存统计信息的表! 我正在苦苦挣扎的是，如何对日期进行
asp.net - 阻止 IE6 访问者
如何放弃使用 IE6 浏览我的网站？就像是 : 如果 ie6 => 死我正在使用 ASP.Net 谢谢最佳答案在asp.net中你可以查看Request.Browser在 Session_st
typescript - TypeScript 中的递归 AST 访问者
我目前正在编写解析器。解析器生成一个 AST，然后我使用各种遍历来处理它。 AST 是(简化的): type LiteralExpr = { readonly kind: 'literal',
c++ - Antlr4 c++ 访问者 API
我正在使用 Antlr4 的 C++ 访问者 api 来遍历解析树。但是，我正在努力使其正常运行。也就是说，我不确定如何使用 visitChildren(ParseTree *tree) 调用。我为
javascript - 同步调用，直到用户被认证为具 Angular 访问者
我的问题是理论性的，而不是如何去做。我想知道专家们如何处理我将在下面描述的情况。我有一个使用 Angular 和 Breeze 的 SPA。身份验证是基于 token 的。我在 Angular 中设
c++ - 具有优先队列的 BGL DFS 访问者
我有一棵树(在图形意义上)表示一棵树(在物理意义上)。树表示为 BGL 邻接列表，其中每个顶点包含半径和位置属性，即，我的图以以下形式定义 struct TreeVertexType { doub
iphone - 有没有办法跟踪 App Store 访问者？
关闭。这个问题是off-topic .它目前不接受答案。想改进这个问题吗？ Update the question所以它是on-topic用于堆栈溢出。关闭 10 年前。 Improve thi
php - 将域限制为 Chrome 访问者？可能的？
是否可以将域限制为仅允许使用特定浏览器的访问者？我正在构建一个应用程序，到目前为止它只在 Chrome 中进行过测试，所以我只想在 Beta 测试期间允许 Chrome 用户。基本上，我想在进行测试
c++ - Clang AST 访问者，避免遍历包含文件
你好，我正在尝试实现一个 AST Clang 访问者，这是我的代码。 class ExampleVisitor : public RecursiveASTVisitor { private:
c++ - Boost Graph initialize_vertex 改变顶点颜色(访问者)
我想构建一个访问者(用于 dikstra)，并将 initialise_vertex 用作“颜色映射”修饰符。我想根据条件从搜索中排除一些顶点。所以我想在算法的初始部分将一些顶点设置为“黑色”。 cl
asp.net - 如果用户 = XXX 访问者，提示输入电子邮件...？
我正在尝试编写一个网站，提示每 10,000 名访问者输入一封可以存储在文本文件中的电子邮件。我设置了一个点击计数器，它将访问者总数输出到一个文本文件中，因此是否可以将脚本设置为类似于 "如果 nu
java - ANTLR 4 和 AST 访问者
我正在尝试将 AST 与 ANTLR4 一起使用，并使用以下文件: 生成器.java import org.antlr.v4.runtime.ANTLRInputStream; import org.
c++ - BGL - BFS/DFS 访问者，访问顶点颜色
在 BGL 中，我不太明白如何在 bfs/dfs 搜索期间访问图中顶点的固有颜色(白色表示未触及，灰色表示已访问，黑色表示已完成)。有人可以说明如何从 dfs/bfs 访问者中访问顶点的颜色吗？例如
javascript - HTML\PHP - 如何获取用户(访问者)的信息
当用户访问您的网站时，如何获取用户的信息？ IP地址苹果地址用户个人资料名称操作系统名称操作系统版本操作系统注册到(姓名/公司) 计算机名浏览器名称浏览器版本 ISP 名称/Intern
php - 如何降低数据传输成本？ Amazon S3 --> Cloudflare --> 访问者
我最近开始使用 Amazon S3 为访问者提供图像，因为这会减少服务器负载。现在，出现了一个新问题:今天我查看了我的 AWS 账单。我注意到我有一大笔账单等着我——20 天内总共有 4TB 的 AW
security - 将 X-Forwarded-For 信任为 "identify"访问者
session 劫持所以我有一个小问题。我正在尝试识别访问者，这很难通过 $_SERVER veriables 来实现，如以下问题所述:Preventing session hijacking .
graph - 我的 TreeMap 的 Arangodb 自定义过滤器/访问者
我有一个带有两个边定义的图，如下所示: isDepartment: [organisation] -> [organisation] hasAccess: [user] -> [organisatio

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 访问者模式用法