访问者模式是一种将数据结构与数据操作分离的设计模式。是指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。属于行为型模式。
访问者模式的基本思想是：针对系统中拥有固定类型数的对象结构，在其内提供一个accept()方法用来接受访问者对象的访问。不同的访问者对同一元素的访问内容不同，使得相同的元素集合可以产生不同的数据结构。accept()方法可以接收不同的访问者对象，然后在内部将自己转发到访问者对象的visit()方法内。访问者内部对应类型的visit()方法就会得到回调执行，对元素进行操作。
也就是通过两次动态分发，最终将一个具体的元素传递到一个具体的访问者。如此依赖，就解耦了数据结构与操作，且数据操作不会改变元素状态。
访问者模式的核心是：解耦数据结构与数据操作，使得对元素的操作具备优秀的扩展性。可以通过扩展不同的数据操作类型（访问者）实现对相同元素集的不同的操作。
1、抽象访问者（Visitor）：接口或抽象类，该类冠以了对每一个具体元素的访问行为visit()方法，其参数就是具体的元素对象。理论上说，Visitor的方法个数与元素个数是相等的。如果元素个数经常变动，会导致Visitor的方法也要进行变动，此时，并不适用访问者模式。
2、具体访问者（ConcreteVisitor）：实现对具体元素的操作。
3、抽象元素（Element）：接口或抽象类，定义了一个接受访问者访问的方法accept()，表示所有元素类型都支持被访问者访问。
4、具体元素（ConcreteElement）：具体元素类型，提供接受访问者的具体实现。通常的实现都为：visitor.visit(this)。
5、结构对象（ObjectStruture）：该类内部维护了元素集合，并提供方法接受访问者对该集合所有元素进行操作。
1、数据结构稳定，作用于数据结构的操作经常变化的场景。
2、需要数据结构于数据操作分离的操作。
3、需要对不同数据类型进行操作，而不适用分支判断具体类型的场景。
抽象元素：Element
public interface Element { void accept(Visitor visitor); }抽象访问者：Visitor
public interface Visitor { void visit(ConcreteElementA element); void visit(ConcreteElementB element); }具体元素：ConcreteElementA
public class ConcreteElementA implements Element{ @Override public void accept(Visitor visitor) { visitor.visit(this); } public String operationA() { return this.getClass().getSimpleName(); } }具体元素：ConcreteElementB
public class ConcreteElementB implements Element{ @Override public void accept(Visitor visitor) { visitor.visit(this); } public int operationB() { return new Random().nextInt(100); } }具体访问者：ConcreteVisitorA
public class ConcreteVisitorA implements Visitor{ @Override public void visit(ConcreteElementA element) { String result = element.operationA(); System.out.println("result from " + element.getClass().getSimpleName() + ": " + result); } @Override public void visit(ConcreteElementB element) { int result = element.operationB(); System.out.println("result from " + element.getClass().getSimpleName() + ": " + result); } }具体访问者：ConcreteVisitorB
public class ConcreteVisitorB implements Visitor{ @Override public void visit(ConcreteElementA element) { String result = element.operationA(); System.out.println("result from " + element.getClass().getSimpleName() + ": " + result); } @Override public void visit(ConcreteElementB element) { int result = element.operationB(); System.out.println("result from " + element.getClass().getSimpleName() + ": " + result); } }结构对象：ObjectStructure
public class ObjectStructure { private List<Element> list = new ArrayList<Element>(); { this.list.add(new ConcreteElementA()); this.list.add(new ConcreteElementB()); } public void accept(Visitor visitor) { for (Element element : this.list) { element.accept(visitor); } } }测试类：
public class Test { public static void main(String[] args) { ObjectStructure collection = new ObjectStructure(); System.out.println("ConcreteVisitorA handle elements:"); Visitor visitorA = new ConcreteVisitorA(); collection.accept(visitorA); System.out.println("------------------------------------"); System.out.println("ConcreteVisitorB handle elements:"); Visitor visitorB = new ConcreteVisitorB(); collection.accept(visitorB); } }抽象元素：Employee
public abstract class Employee { public String name; public int kpi; //员工KPI public Employee(String name) { this.name = name; kpi = new Random().nextInt(10); } //接收访问者的访问 public abstract void accept(Visitor visitor); }抽象访问者：Visitor
public interface Visitor { void visit(Engineer engineer); void visit(Manager manager); }具体元素：Engineer
public class Engineer extends Employee { public Engineer(String name) { super(name); } @Override public void accept(Visitor visitor) { visitor.visit(this); } //考核指标是每年的代码量 public int getCodeLines() { return new Random().nextInt(10 * 10000); } }具体元素：Manager
public class Manager extends Employee { public Manager(String name) { super(name); } @Override public void accept(Visitor visitor) { visitor.visit(this); } //考核的是每年新产品研发数量 public int getProducts() { return new Random().nextInt(10); } }具体访问者：CEOVisitor
public class CEOVisitor implements Visitor { @Override public void visit(Engineer engineer) { System.out.println("工程师" + engineer.name + "，KIP：" + engineer.kpi); } @Override public void visit(Manager manager) { System.out.println("经理：" + manager.name + ",KPI:" + manager.kpi + "，产品数量：" + manager.getProducts()); } }具体访问者：CTOVisitor
public class CTOVisitor implements Visitor { @Override public void visit(Engineer engineer) { System.out.println("工程师" + engineer.name + "，代码行数：" + engineer.getCodeLines()); } @Override public void visit(Manager manager) { System.out.println("经理：" + manager.name + "，产品数量：" + manager.getProducts()); } }结构对象：BusinessReport
public class BusinessReport { private List<Employee> employees = new LinkedList<Employee>(); public BusinessReport() { employees.add(new Manager("产品经理A")); employees.add(new Engineer("程序员A")); employees.add(new Engineer("程序员B")); employees.add(new Engineer("程序员C")); employees.add(new Manager("产品经理B")); employees.add(new Engineer("程序员D")); } public void showReport(Visitor visitor) { for (Employee employee : employees) { employee.accept(visitor); } } }测试类：
public class Test { public static void main(String[] args) { BusinessReport report = new BusinessReport(); System.out.println("==========CEO看报表==============="); report.showReport(new CEOVisitor()); System.out.println("==========CTO看报表==============="); report.showReport(new CTOVisitor()); } } 1、解耦了数据结构与数据操作，使得操作集合可以独立变化。
2、扩展性好，可以通过扩展访问者角色，实现对数据集的不同操作。
3、元素具体类型并非单一，访问者均可操作。
4、各角色职责分离，符合单一职责原则。
1、无法增加元素类型：若系统数据结构对象易于变化，经常有新的数据对象增加进来，则访问者类必须增加对应元素类型的操作，违背了开闭原则。
2、具体元素变更困难：具体元素增加属性，删除属性等操作会导致对应的访问者类需要进行相应的修改，尤其当有大量访问者类时，修改范围太大。
3、违背依赖倒置原则：为了达到“区别对待”，访问者依赖的是具体元素类型，而不是抽象。
链接: 七大设计原则的简单解释（包含合成复用原则），简单理解、快速入门，具备案例代码.
链接: 工厂模式详解附有代码案例分析（简单工厂，工厂方法，抽象工厂）.
链接: 单例模式详解及代码案例与应用场景（饿汉式单例模式、懒汉式单例模式、注册式单例模式）.
链接: 原型模式详解附有代码案例分析（浅克隆和深克隆的相关解析）.
链接: 建造者模式详解附有代码案例分析（包含建造者模式与工厂模式的区别分析）.
链接: 门面模式详解附有代码案例分析.
链接: 装饰者模式详解附有代码案例分析.
链接: 享元模式详解附有代码案例分析（包含享元模式的源码应用分析——String中的享元模式应用、Integer中的享元模式应用）.
链接: 组合模式详解附有代码案例分析（包含透明组合模式、安全组合模式的代码示例）.
链接: 桥接模式详解附有代码案例分析.
链接: 适配器模式详解附有代码案例分析（包含类适配器、对象适配器以及接口适配器的代码示例）.
链接: 委派模式详解附有代码案例分析（包含委派模式在JDK中的源码示例解析）.
链接: 模板方法模式详解附有代码案例分析（包含模板方法模式重构JDBC操作业务代码示例）.
链接: 策略模式详解附有代码案例分析（包含策略模式在源码中的应用以及代码示例）.
链接: 责任链模式详解附有代码案例分析（包含责任链模式与建造者模式的结合代码案例）.
链接: 迭代器模式详解附有代码案例分析（包含迭代器模式的源码应用分析）.
链接: 命令模式详解附有代码案例分析（包含命令模式的源码应用分析）.
链接: 状态模式详解附有代码案例分析（包含状态模式与其他相关设计模式的对比）.
链接: 备忘录模式详解附有代码案例分析.
链接: 中介者模式详解附有代码案例分析.
链接: 解释器模式详解附有代码案例分析.
链接: 观察者模式详解附有代码案例分析（包含观察者模式使用JDK方式实现）.
链接: 访问者模式详解附有代码案例分析.
