访问者模式

1解决问题:

有稳定的数据结构，易变的算法。

换句话说，就是被处理的对象就那么多（稳定的数据结构），而对这些对象，可能有不同的操作（易变的算法），每种算法作用于每类对象上都产生不同结果。

数据结构就是“元素”

算法就是“访问者”

如果在数据结构上判断“究竟是那个操作作用用它”，那么会有很长的if-else，不好。

而且操作的数量很可能变化，此时就需要改变“数据结构”里的if-else

 

2解决方法：

调用点由“元素”内部转向“访问者内部”

即 原来是：

我是元素A，如果我收到了访问命令x，那么我。。。。，如果我收到了命令y，那么我。。。。

现在是：

我是命令x，如果我去作用于元素A，那么它。。。。，如果我作用于元素B，那么它。。。。

由于元素的个数稳定 且远少于 命令（访问者）的个数

所以此时在访问者内部的“分支判断”就很小，甚至更好的做法是直接用不同的函数区分的。

 

 

3

public interface AbstractElement {
	public  void accept(AbstractVisitor v);
}

 

public class ElementA implements AbstractElement{

	public void accept(AbstractVisitor v) {
		v.visitElementA(this);
	}
	
	public String getName(){
		return "aaa";
	}
}

 

public class ElementB implements AbstractElement{

	public void accept(AbstractVisitor v) {
		v.visitElementB(this);
	}
	
	public String getName(){
		return "bbb";
	}
}

 

public interface AbstractVisitor {
	public void visitElementA(ElementA a);
	public void visitElementB(ElementB b);
}

 

public class VisitorA implements AbstractVisitor{

	public void visitElementA(ElementA a) {
		System.out.println("visitor a visit element a,then a will do sth:" + a.getName());
	}

	public void visitElementB(ElementB b) {
		System.out.println("visitor a visit element b,then b will do sth:" + b.getName());
	}
}

 

public class VisitorB implements AbstractVisitor{

	public void visitElementA(ElementA a) {
		System.out.println("visitor b visit element a,then a will do sth:" + a.getName());
	}

	public void visitElementB(ElementB b) {
		System.out.println("visitor b visit element b,then b will do sth:" + b.getName());
	}
}

 

public class ObjectStructure {
	public List<AbstractElement> elements = new LinkedList<AbstractElement>();
	public void attach(AbstractElement e){
		elements.add(e);
	}
	public void detach(AbstractElement e){
		elements.remove(e);
	}
	
	public void acceptAll(AbstractVisitor v){
		for(AbstractElement e : elements){
			e.accept(v);
		}
	}
}

 

public class Demo {
	public static void main(String[] args) {
		ObjectStructure o = new ObjectStructure();
		AbstractElement e1 = new ElementA();
		AbstractElement e2 = new ElementB();
		
		AbstractVisitor v1 = new VisitorA();
		AbstractVisitor v2 = new VisitorB();
		
		o.attach(e1);
		o.attach(e2);
		
		o.acceptAll(v1);
		o.acceptAll(v2);
	}
}