首先

抽象员工

public abstract class Employee{    // 代表男性    public final static int MALE = 0;    // 代表女性    public final static int FEMALE = 1;    // 有工资    private String name;    // 薪水    private int salary;    // 性别    private int sex;    // get/set    public String getName(){        return name;    }    public void setName(String name){        this.name = name;    }    public int getSalary(){        return salary;    }    public void setSalary(int salary){        this.salary = salary;    }    public int  getSex(){        return sex;    }    public void setSex(int sex){        this.sex = sex;    }    // 员工信息输出    public final void report(){        String info = "姓名" + this.name + "\t";        info = info + "性别" + this.sex + "\t";        info = info + "薪水" + this.salary + "\t";        info = info + this.getOtherinfo();        System.out.println(info);    }    // 拼装    protected abstract String getOtherinfo();}

下面是普通员工

public class CommonEmployee extends Employee{    // 工作内容    private String job;    public String getJob(){        return job;    }    public void setJob(String job){        this.job = job;    }    protected String getOtherinfo(){        return "工作: " + this.job + "\t";    }}

管理层

public class Manager extends Employee{    // 职责    private String performance;    public String getPerformance(){        return performance;    }    public void setPerformance(String performance){        this.performance = performance;    }    protected String getOtherinfo(){        return "业绩" + this.performance + "\t";    }}

最后场景

public class Client{    public static void main(String[] args){        for(Employee emp:mockEmployee()){            emp.report();        }    }    public static List mockEmployee(){        List empList = new ArrayList();        // 产生员工        CommonEmployee zhangSan = new CommonEmployee();        zangSan.setJon("编写程序");        zangSan.setName("张三");        zangSan.setSalary(1800);        zangSan.setSex(Employee.MALE);        empList.add(zangSan);        // 产生员工        CommonEmployee liSi = new CommonEmployee();        liSi.setJob("美工");        liSi.setName("李四");        liSi.setSalary(1900);        liSi.setSex(Employee.FEMALE);        empList.add(liSi);        // 产生经理        Manage wangWu = new Manger();        wangWu.setName("王五");        wangWu.setPerformance("负值");        wangWu.setSalary(18750);        wangWu.setSex(Employee.MALE);        empList.add(wangWu);        return empList;    }}

改造如下

先定义访问者接口

public interface IVisitor{    // 定义普通员工    public void vsit(CommonEmployee commonEmployee);    // 定义访问部门经理    public void visit(Manager manager);}

访问者实现

public class Visitor implements IVisitor{    // 访问普通员工，打印报表    public void visit(CommonEmployee commonEmployee){        System.out.println(this.getCommonEmployee(commonEmployee));    }    // 访问部门经理    public void visit(Manager manager){        System.out.println(this.getManagerinfo(manager));    }    // 组装基本信息    private String getBasicinfo(Employee employee){        String info = "姓名" + employee.getName() + "\t";        info = info + "性别" + (employee.getSex() == Employee.FEMALE?"女","男");        info = info + "薪水" + employee.getSalary() + "\t";        return info;    }    // 组装普通员工信息    private String getCommonEmployee(CommonEmployee commonEmployee){        String basicinfo = this.getBasicinfo(commonEmployee);        String otherinfo = "工作" + commonEmployee.getJob() + "\t";        return basicinfo + otherinfo;    }    }

继续书写抽象员工类

public abstract class Employee{    public final static int MALE = 0;    public final static int FEMALE = 1;    // 工资    private String name;    // 薪水    private int salary;    // 性别    private int sec;    // get/set    public String getName(){        return name;    }    public void setName(String name){        this.name = name;    }    public int getSalary(){        return salary;    }    public void setSalary(int salary){        this.salary = salary;    }    public int getSex(){        return sex;    }    public void setSex(int sex){        this.sex = sex;    }    // 定义访问者访问    public abstract void accept(IVisitor visitor);}

普通员工

public class CommonEmployee extends Employee{    // 工作内容    private String job;    // 获得job    public String getJon(){        return job;    }    // 设置job    public void setJob(String job){        this.job = job;    }    // 允许访问者访问    @Override    public void accept(IVsitor visitor){        visitor.visit(this);    }}

场景类

public class Client{    public static void main(String[] args){        // 开始循环列表        for(Employee emp:mockEmployee()){            // 将访问者传入，此时accept将会调用visit方法，将this传入            emp.accept(new Visitor());        }    }    public static List mockEmployee(){        List empList = new ArrayList();        // 产生员工        CommonEmployee zhangSan = new CommonEmployee();        // 设置属性        zhangSan.setJon("编写程序");        zhangSan.setName("张三");        zhangSan.setSalary(1800);        zhangSan.setSex(Employee.MALE);        empList.add(zhangSan);        // 产生员工        CommonEmployee liSi = new CommonEmployee();        liSi.setJob("美工");        liSi.setSalary("李四");        liSi.setSalary(1900);        liSi.setSex(Employee.FEMALE);        // 入数组        empList.add(liSi);        // 产生经理        Manager wangWu = new Manager();        wangWu.setName("王五");        wangWu.setPerformance("负数");        wangWu.setSalary(18750);        wangWu.setSex(Employee.MALE);        empList.add(wangWu);        return empList;    }}

扩展

统计功能

汇总和报表，经常使用统计功能。

即，一堆计算公式，生产出一个报表。

统计公式员工的工资总额

// 定义抽象访问者public interface IVisitor{    // 定义可以访问的普通员工    public void visit(CommonEmployee commonEmployee);    // 再次定义访问部门经理    public void visit(Manager manager);    // 统计员工工资总和    public int getTotalSalary();}

定义访问者

// public class Visitor implements IVisitor{    // 这里实现接口}

最后编写场景类

public class Client{    public static void main(String[] args){        // 定义一个访问者        // 展示报表的访问者        ISVisitor showVisitor = new Visitor();        // 汇总报表的访问者        ITotalVisitor totalVisitor = new TotalVisitor();        // 遍历,其中mockEmployee是从持久层传来的数据        for(Employee emp:mockEmployee()){            // 对数据进行处理，            // 代执行访问着的visit方法。由于数据是保存在emp的，所以需要将this传入            emp.accept(showVisitor);            emp.accept(totalVisitor);        }        System.out.println("");    }}

双分派

单分派：处理一个操作根据请求着的名称和接受到的参数决定

静态绑定，动态绑定，依据重载，覆写实现。

栗子

// 定义角色接口，实现类public interface Role{    // 演员扮演的角色}public class KungFuRole implements Role{    // 武功第一的角色}public class idiotRole implements Role{    // 弱智角色}

下面定义抽象演员

public abstract class AbsActor{    // 演员能够扮演的角色    public void act(Role role){        // 演员扮演的角色    }    // 扮演功夫戏    public void act(KungFuRole role){        // 扮演功夫戏    }}

// 青年演员，老年演员public class YoungActor extends AbsActor{    // 年轻演员喜欢的功夫戏    public void act(KungFuRole role){        }}

// 老年演员喜欢的功夫戏public class OldActor extends AbsActor{    // 扮演功夫角色    public void act(KungFuRole role){        // 扮演功夫角色    }}

编写场景

public class Client{    public static void main(String[] args){        // 定义一个演员        AbsActor actor = new OldActor();        // 定义一个角色        Role role = new KungFuRole();        // 开始演戏        actor.act(role);        actor.act(new KungFuRole());    }}

重载在编译期间决定要调用那个方法。

静态绑定，是重写的时候就断定要绑定那个，例如定义年轻演员的时候，重写的act方法，此时为静态绑定了KungFuRole，

动态绑定呢，act方法，只有在运行的时候才能判断是和那个绑定

一个演员可以扮演多个角色，如何实现呢，使用访问者模式

public interface Role{    // 演员扮演的角色    public void accept(AbstActor actor);}public class KungFuRole implements Role{    // 角色    public void accept(Abstract actor){        actor.act(this);    }}public class ldiotRole implements Role{    // 弱智角色    public void accept(AbsActor actor){        actor.act(this);    }}书写场景类public class Clicent{    public static void main(String[] args){        // 定义演员        AbsActor actor = new OldActor();        // 定义角色        Role role = new KungFuRole();        // 开始演戏        role.accept(actor);    }}