摘要：
它可以使你在不改变这些对象本身的情况下，定义作用于这些对象的新操作。
一、概述
概念
作用于某个对象群中各个对象的操作。它可以使你在不改变这些对象本身的情况下，定义作用于这些对象的新操作。
引入
试想这样一个场景，在一个Collection中放入了一大堆的各种对象的引用，取出时却需要根据这些对象的不同具体类型执行不同操作，那我们有如下方案：
public voidshow(Collection c) {
Iterator it =c.iterator();
while(it.hasNext()) {
Object o =it.next();
if (o instanceofInteger) {
//Integer对应的操作
} else if (o instanceofString) {
//String对应的操作
} else if (o instanceofCollection) {
//Collection对应的操作
} else{
//省略若干个else if
}
}
}就不分析说这段代码到底有什么问题了，我们直接引入解决办法：访问者模式——把数据结构和数据结构之上的操作解耦
UML简图
结构
角色
抽象访问者：声明多个访问操作
具体访问者：实现接口中操作
抽象节点：声明接受操作，接收访问者作为一个参量
具体节点：实现接受操作
结构对象：可以遍历结构中所有元素
二、实践
根据角色给出示意性代码：
抽象访问者
/**
* 访问者接口
*
* @authorAdministrator
**/
public interfaceVisitor {
/**
* 访问NodeA
* @paramnode 访问结点
*/
voidvisit(NodeA node);
/**
* 访问NodeB
* @paramnode 访问结点
*/
voidvisit(NodeB node);
}具体访问者
/**
* 访问者A
*
* @authorAdministrator ON 2017/11/3
**/
public class VisitorA implementsVisitor{
@Override
public voidvisit(NodeA nodeA) {
System.out.println(nodeA.operationA());
}
@Override
public voidvisit(NodeB nodeB) {
System.out.println(nodeB.operationB());
}
}/**
* 访问者B
*
* @authorAdministrator ON 2017/11/3
**/
public class VisitorB implementsVisitor{
@Override
public voidvisit(NodeA nodeA) {
System.out.println(nodeA.operationA());
}
@Override
public voidvisit(NodeB nodeB) {
System.out.println(nodeB.operationB());
}
}抽象结点
/**
* 抽象节点
*
* @authorAdministrator ON 2017/11/3
**/
public abstract classNode {
public abstract voidaccept(Visitor v);
}具体结点
/**
* A结点
*
* @authorAdministrator ON 2017/11/3
**/
public class NodeA extendsNode{
@Override
public voidaccept(Visitor v) {
v.visit(this);
}
publicString operationA() {
return "A结点特有方法";
}
}/**
* B结点
*
* @authorAdministrator ON 2017/11/3
**/
public class NodeB extendsNode{
@Override
public voidaccept(Visitor v) {
v.visit(this);
}
publicString operationB() {
return "B结点特有方法";
}
}结构对象
/**
* 结构对象
*
* @authorAdministrator ON 2017/11/3
**/
public classObjectStructure {
private List<Node>nodeList;
privateNode node;
publicObjectStructure() {
nodeList = new ArrayList<>();
}
/**
* 执行访问操作
*/
public voidaction(Visitor v) {
Iterator<Node> iterator =nodeList.iterator();
while(iterator.hasNext()) {
node =iterator.next();
node.accept(v);
}
}
/**
* 增加一个新结点
* @paramnode 待增加的结点
*/
public voidadd(Node node) {
nodeList.add(node);
}
}客户端简单操作：
public static voidmain(String[] args) {
//新建并初始化结构对象
ObjectStructure os = newObjectStructure();
os.add(newNodeA());
os.add(newNodeB());
//新增访问者并访问
Visitor v1 = newVisitorA();
os.action(v1);
}
我们根据访问者的核心，把上面提出的问题使用访问者模式进行改进
访问者接口——通过重载实现了不同类型的不同访问
/**
* 集合访问者接口
*
* @authorAdministrator
**/
public interfaceCollectionVisitor {
/**
* 访问String元素
* @paramse String类型元素
*/
voidvisit(StringElement se);
/**
* 访问Integer类型元素
* @paramie Integer类型元素
*/
voidvisit(IntegerElement ie);
}具体访问者
/**
* 具体访问者
*
* @authorAdministrator ON 2017/11/3
**/
public class ConcreteVisitor implementsCollectionVisitor{
@Override
public voidvisit(StringElement se) {
System.out.println(se.stringValue());
}
@Override
public voidvisit(IntegerElement ie) {
System.out.println(ie.integerValue());
}
}抽象被访问元素——通过accept接收访问者
/**
* 元素接口
*
* @authorAdministrator ON 2017/11/3
**/
public interfaceElement {
/**
* 接收访问
* @paramvisitor 访问者
*/
voidaccept(CollectionVisitor visitor);
}具体元素
/**
* String类型的元素
*
* @authorAdministrator ON 2017/11/3
**/
public class StringElement implementsElement{
@Override
public voidaccept(CollectionVisitor visitor) {
visitor.visit(this);
}
publicString stringValue() {
return "StringElement";
}
}/**
* Integer类型元素
*
* @authorAdministrator ON 2017/11/3
**/
public class IntegerElement implementsElement{
@Override
public voidaccept(CollectionVisitor visitor) {
visitor.visit(this);
}
publicInteger integerValue() {
return 1;
}
}客户端使用
/**
* 客户端
* @authorAdministrator
**/
public classClient {
public static voidmain(String[] args) {
//创建需要访问的元素对象集合
List<Element> elementList = new ArrayList<>();
elementList.add(newStringElement());
elementList.add(newIntegerElement());
//创建访问者
CollectionVisitor visitor = newConcreteVisitor();
//接收访问者开始访问
for(Element element : elementList) {
element.accept(visitor);
}
}
}三、改进与思考
应当指明，只有在系统十分稳定，确定不会加入新结点时使用，因为加入新节点将无法做到“开闭原则”
特别注意，访问者模式是解决了不停判断的问题！可以直接根据传入的参数进行判断和接收（回传球）
浅显的栗子请参见：http://ifeve.com/visitor-design-pattern-in-java-example-tutorial/