访问者模式

案例：计价员拿到采购单之后根据采购单物品名称和数量计算总价，采购员根据采购单名称和数量采购。采购单看作采购物集合，不同操作人员对采购单进行不同处理。

 

 

• 包含访问者和被访问元素两个主要组成。被访问元素通常有不同的类型，不同访问者可对它们进行不同访问操作。
• 被访问元素通常不单独存在，存储在一个集合中，集合被称为“对象结构”，访问者遍历对象结构对存储的元素逐个操作。

 

抽象访问者：为对象结构中每一个具体元素声明一个访问操作，从这个操作名称或参数类型可以清楚知道需要访问的具体元素的类型

 

 

//抽象访问者
abstract class Department {
    public abstract void visit(FulltimeEmployee employee);
    public abstract void visit(ParttimeEmployee employee);
}

 

 

具体访问者：实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型元素

 

 

//财务部类:具体访问者类
class FADepartment extends Department {
    //实现财务部对全职员工的访问
    public void visit(FulltimeEmployee employee) {
        int workTime = employee.getWorkTime();
        double weekWage = employee.getWeeklyWage();
        if (workTime > 40) {
            weekWage = weekWage + (workTime - 40) * 100;
        } else if (workTime < 40) {
            weekWage = weekWage - (40 - workTime) * 80;
            if (weekWage < 0) {
                weekWage = 0;
            }
        }
        System.out.println("正式员工" + employee.getName() + "实际工资为:" + weekWage + "元。");
    }

    //实现财务部对兼职员工的访问
    public void visit(ParttimeEmployee employee) {
        int workTime = employee.getWorkTime();
        double hourWage = employee.getHourWage();
        System.out.println("临时工" + employee.getName() + "实际工资为:" + workTime * hourWage + "元。");
    }
}

 

 

 

//人力资源部类:具体访问者类
class HRDepartment extends Department {
    //实现人力资源部对全职员工的访问
    public void visit(FulltimeEmployee employee) {
        int workTime = employee.getWorkTime();
        System.out.println("正式员工" + employee.getName() + "实际工作时间为:" + workTime + "小
        if (workTime > 40) {
            System.out.println("正式员工" + employee.getName() + "加班时间为:" + (workTime - 40) +
                    "小时。");
        } else if (workTime < 40) {
            System.out.println("正式员工" + employee.getName() + "请假时间为:" + (40 - workTime) +
        }
    }

    //实现人力资源部对兼职员工的访问
    public void visit(ParttimeEmployee employee) {
        int workTime = employee.getWorkTime();
        System.out.println("临时工" + employee.getName() + "实际工作时间为:" + workTime + "小时。");
    }
}

 

 

抽象元素：抽象元素一般是抽象类或者接口，定义一个accept()方法，该方法通常以一个抽象访问者作为参数。

 

 

interface Employee {
    //接受一个抽象访问者访问
    public void accept(Department handler); 
}

 

 

具体元素：实现了accept方法，在accept方法中调用访问者的访问方法完成对一个元素的操作。

 

 

class FullTimeEmployee implements Employee {
    private String name;
    private double weeklyWage;
    private int workTime;

    public FullTimeEmployee(String name, double weeklyWage, int workTime) {
        this.name = name;
        this.weeklyWage = weeklyWage;
        this.workTime = workTime;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setWeeklyWage(double weeklyWage) {
        this.weeklyWage = weeklyWage;
    }

    public void setWorkTime(int workTime) {
        this.workTime = workTime;
    }

    public String getName() {
        return (this.name);
    }

    public double getWeeklyWage() {
        return (this.weeklyWage);
    }

    public int getWorkTime() {
        return (this.workTime);
    }

    public void accept(Department handler) {
        handler.visit(this); //调用访问者的访问方法
    }
}

 

 

 

class PartTimeEmployee implements Employee {
    private String name;
    private double hourWage;
    private int workTime;

    public PartTimeEmployee(String name, double hourWage, int workTime) {
        this.name = name;
        this.hourWage = hourWage;
        this.workTime = workTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHourWage() {
        return hourWage;
    }

    public void setHourWage(double hourWage) {
        this.hourWage = hourWage;
    }

    public int getWorkTime() {
        return workTime;
    }

    public void setWorkTime(int workTime) {
        this.workTime = workTime;
    }

    public void accept(Department handler) {
        handler.visit(this); //调用访问者的访问方法 
    }
}

 

对象结构  是一个元素的集合，它用于存放元素对象，并且提供遍历其内部元素方法。它结合组合模式实现，也可以是一个简单的集合对象，如一个List或一个Set。

class EmployeeList {
    //定义一个集合用于存储员工对象
    private ArrayList<Employee> list = new ArrayList<Employee>();

    public void addEmployee(Employee employee) {
        list.add(employee);
    }

    //遍历访问员工集合中的每一个员工对象
    public void accept(Department handler) {
        for (Object obj : list) {
            ((Employee) obj).accept(handler);
        }
    }
}

 

• 要在系统中增加一种新的访问者，只要增加一个新的具体访问者类即可，从增加新的访问者角度看，模式符合“开闭原则”。
• 要在系统中增加一种新的具体元素，如“退休人员”，则必须对原有系统修改，在原有抽象访问者类中增加访问方法。从增加新的元素角度看，模式违背“开闭原则”。
• 模式很方便地添加新的访问者，但添加新元素较麻烦

适用场景

 

1. 对象结构中对象对应类很少改变，但经常要在此对象结构上定义新操作。
2. 一个对象结构包含多个类型的对象，在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。
3. 需要对一个对象结构中的对象进行很多不同不相关操作，不希望在增加新操作时修改这些类。将相关访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。

参考：刘伟设计模式