设计模式-第24章（访问者模式）

访问者模式

访问者模式（Visitor），表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各个元素的类的前提下定义作用于这些元素的新操作。

Visitor 访问者类。
ConcreteVisitor1，ConcreteVisitor2 具体的访问者类，每一个访问者类就是对结构对象的的一种具体的操作。
Element 抽象数据结构类。
ConcreteElement1，ConcreteElement2 具体的数据结构。

访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间耦合解脱开，使得操作集合可以相对自由地演化。

访问者模式的目的是要把处理从数据结构分离出来。如果系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。

如果系统的数据结构对象易于变化，就不适合使用访问者模式。

访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

访问者模式的缺点就是使增加新的数据结构变得困难了。

访问者模式基本代码

Visitor 类，为每一个具体的数据结构声明一个Visit操作。

abstract class Visitor {
    public abstract void visitConcreteElementA(ConcreteElementA concreteElementA);
    public abstract void visitConcreteElementB(ConcreteElementB concreteElementB);
}

ConcreteVisitor1 和 ConcreteVisitor2类，具体访问者。

class ConcreteVisitor1 extends Visitor {
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName()+"被"+
        					this.getClass().getSimpleName()+"访问");
    }
    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
            System.out.println(concreteElementB.getClass().getSimpleName()+"被"+
            					this.getClass().getSimpleName()+"访问");
    }
}

class ConcreteVisitor2 extends Visitor {
    public void visitConcreteElementA(ConcreteElementA concreteElementA) {
        System.out.println(concreteElementA.getClass().getSimpleName()+"被"+
        					this.getClass().getSimpleName()+"访问");
    }
    public void visitConcreteElementB(ConcreteElementB concreteElementB) {
        System.out.println(concreteElementB.getClass().getSimpleName()+"被"+
        					this.getClass().getSimpleName()+"访问");
    }
}

Element 类

abstract class Element {
    public abstract void accept(Visitor visitor);
}

ConcreteElementA ，ConcreteElementB具体的数据结构。

class ConcreteElementA extends Element {
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementA(this);
    }
    public void operationA(){ 
    }
}

class ConcreteElementB extends Element {
    public void accept(Visitor visitor) {
        visitor.visitConcreteElementB(this);
    }
    public void operationB(){ 
    }
}

ObjectStructure 类，能枚举它的元素，可以提供一个高层的接口，以允许访问者访问它的元素。

class ObjectStructure {
    private ArrayList<Element> elements = new ArrayList<Element>();
    public void attach(Element element) {
        elements.add(element);
    }
    public void detach(Element element) {
        elements.remove(element);
    }
    // 访问者访问每一个元素
    public void accept(Visitor visitor) {
        for(Element e : elements) {
            e.accept(visitor);
        }
    }
}

客户端

public class Test {
    public static void main(String[] args) {
        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 
		// 定义ObjectStructure对象
        ObjectStructure o = new ObjectStructure();
        o.attach(new ConcreteElementA());
        o.attach(new ConcreteElementB());
		// 定义访问者对象
        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();
		// 使用访问者对象，访问每一个元素
        o.accept(v1);
        o.accept(v2);
        System.out.println();
        System.out.println("**********************************************");
    }
}

访问者模式的应用

男人和女人对于不同的问题会有不同的动作。

Person 人，Man 男人，Woman女人。
Action 动作，Success，Failing，Amativeness 具体的动作。

访问者模式适用于数据结构稳定的系统。 在这个例子中，人只有男人和女人，结构非常稳定。

人类抽象类

abstract class Person {
    //接受
    public abstract void accept(Action visitor);
}

男人类，女人类

//男人类
class Man extends Person {
    public void accept(Action visitor) {
        visitor.getManConclusion(this);
    }
}
//女人类
class Woman extends Person {
    public void accept(Action visitor) {
        visitor.getWomanConclusion(this);
    }
}

ObjectStructure 对象结构

class ObjectStructure {
    private ArrayList<Person> elements = new ArrayList<Person>();

    //增加
    public void attach(Person element) {
        elements.add(element);
    }
    //移除
    public void detach(Person element) {
        elements.remove(element);
    }
    //查看显示
    public void display(Action visitor) {
        for(Person e : elements) {
            e.accept(visitor);
        }
    }
}

Action 状态抽象类

abstract class Action{
    //得到男人结论或反应
    public abstract void getManConclusion(Man concreteElementA);
    //得到女人结论或反应
    public abstract void getWomanConclusion(Woman concreteElementB);
}

具体状态

//成功
class Success extends Action{
    public void getManConclusion(Man concreteElementA){
        System.out.println(concreteElementA.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，背后多半有一个伟大的女人。");
    }    
    public void getWomanConclusion(Woman concreteElementB){
        System.out.println(concreteElementB.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，背后大多有一个不成功的男人。");
    }
}
//失败
class Failing extends Action{
    public void getManConclusion(Man concreteElementA){
        System.out.println(concreteElementA.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，闷头喝酒，谁也不用劝。");
    }    
    public void getWomanConclusion(Woman concreteElementB){
        System.out.println(concreteElementB.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，眼泪汪汪，谁也劝不了。");
    }
}
//恋爱
class Amativeness extends Action{
    public void getManConclusion(Man concreteElementA){
        System.out.println(concreteElementA.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，凡事不懂也要装懂。");
    }    
    public void getWomanConclusion(Woman concreteElementB){
        System.out.println(concreteElementB.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()+"时，遇事懂也装作不懂。");
    }
}
//结婚
class Marriage extends Action{
    public void getManConclusion(Man concreteElementA){
        System.out.println(concreteElementA.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()
            +"时，感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。");
    }    
    public void getWomanConclusion(Woman concreteElementB){
        System.out.println(concreteElementB.getClass().getSimpleName()
            +" "+this.getClass().getSimpleName()
            +"时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。");
    }
}

客户端

public class Test {
    public static void main(String[] args) {
        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 
        ObjectStructure o = new ObjectStructure();
        o.attach(new Man());
        o.attach(new Woman());
        
        //成功时的反应
        Success v1 = new Success();
        o.display(v1);
 
        //失败时的反应
        Failing v2 = new Failing();
        o.display(v2);
        
        //恋爱时的反应
        Amativeness v3 = new Amativeness();
        o.display(v3);
        
        //婚姻时的反应
        Marriage v4 = new Marriage();
        o.display(v4);
        
        System.out.println();
        System.out.println("**********************************************");
    }
}

访问者模式将结构和操作进行解耦，如果想要增加新的操作，只需要增加新的访问者类即可。不需要改动其他任何代码，完美地体现了开放-封闭原则。