设计模式------访问者模式

访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同，执行不同的操作

把类分成了两个部分，一部分是存储信息的，一部分是展示信息的

他和策略模式有相同点哈。。。。但是有那么一点点不同
public abstarct class Employee{
    ......
   public final void report(){
        String info = "姓名：" + this.name + "\t";
        info = info + "性别：" + (this.sex == FEMALE?"女":"男") + "\t";
         info = info + "薪水：" + this.salary + "\t";
         //获得员工的其他信息
          info = info + this.getOtherInfo();
            System.out.println(info);
   }
        //拼装员工的其他信息
      protected abstract String getOtherInfo();
}

/**
* @author cbf4Life [e-mail]
* I'm glad to share my knowledge with you all.
* 普通员工，也就是最小的小兵
*/
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";
         }
}

/**
* @author cbf4Life [e-mail]
* I'm glad to share my knowledge with you all.
* 经理级人物
*/
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";
             }
}

但是不幸的是。。。。一个类中的东西也是不稳定的。。。这个类中的report()方法需要适应不同的变化。。。那么把他们放到CommonEmployee 和Manager 中不就得了。。但是需求是每个类中也不一定稳定。。。比如过几天我就想换一种方法来report()....

既然放到实现类中都不稳定。。那么只能用接口啦。。。。
public abstarct class Employee{
    ......
  public abstract void accept(IVisitor visitor); //这里都变，那么只能用接口
    
}

而这里与策略不同的是。。。。策略中的东西侧重点是实现一票其他的算法，这些算法与当事人无关。。。。而访问者中变化的东西还得访问原来的对象。。
public class Visitor implements IVisitor {
           //访问普通员工，打印出报表
           public void visit(CommonEmployee commonEmployee) { //关键点在这里，他接受一个自己的对象，然后再做操作，也就是实现的时候要传一个参数，而这个参数是this而已啦
                      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?"女":"男")
           + "\t";
                      info = info + "薪水：" + employee.getSalary() + "\t";
                      return info;
           }
           //组装出部门经理的信息
           private String getManagerInfo(Manager manager){
                      String basicInfo = this.getBasicInfo(manager);
                      String otherInfo = "业绩："+manager.getPerformance() + "\t"     
           return basicInfo + otherInfo;
           }
           //组装出普通员工信息
           private String getCommonEmployee(CommonEmployee commonEmployee){
                      String basicInfo = this.getBasicInfo(commonEmployee);
                      String otherInfo = "工作："+commonEmployee.getJob()+"\t";
                      return basicInfo + otherInfo;
           }
}


public class CommonEmployee extends Employee {
。。。。。。。
@Override
      public void accept(IVisitor visitor){
           visitor.visit(this);
      }
}