男人和女人--访问者模式

1.1 男人和女人

男人这本书的内容要比封面吸引人，女人这本书的封面通常是比内容更吸引人。
男人的青春表示一种肤浅，女人的青春标志一种价值。
男人在街上东张西望，被称作心怀不轨；女人在路上左瞅右瞧，被叫作明眸善睐。
男人成功时，背后多半有一个伟大的女人。女人成功时，背后大多有一个不成功的男人。
男人失败时，闷头喝酒，谁也不用劝。女人失败时，眼泪汪汪，谁也劝不了。
男人恋爱时，凡事不懂也要装懂。女人恋爱时，遇事懂也装作不懂。
男人结婚时，感慨道：恋爱游戏终结时，'有妻徒刑'遥无期。女人结婚时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。

1.2 最简单的编程实现

package code.chapter28.visitor1;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 

        System.out.println("男人成功时，背后多半有一个伟大的女人。");
        System.out.println("女人成功时，背后大多有一个不成功的男人。");
        System.out.println("男人失败时，闷头喝酒，谁也不用劝。");
        System.out.println("女人失败时，眼泪汪汪，谁也劝不了。");
        System.out.println("男人恋爱时，凡事不懂也要装懂。");
        System.out.println("女人恋爱时，遇事懂也装作不懂。");

        System.out.println();
        System.out.println("**********************************************");
    }
}

        这里面至少男人和女人应该是两个不同的类，男人和女人应该继承人这样一个抽象类。所谓的成功、失败或恋爱都是指人的一个状态，是一个属性。成功时如何如何，失败时如何如何不过是一种反应。

1.3 简单的面向对象实现

package code.chapter28.visitor2;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {

        System.out.println("**********************************************");       
        System.out.println("《大话设计模式》代码样例");
        System.out.println(); 

        ArrayList<Person> persons = new ArrayList<Person>();

        Person man1 = new Man();
        man1.setAction("成功");
        persons.add(man1);
        Person woman1 = new Woman();
        woman1.setAction("成功");
        persons.add(woman1);

        Person man2 = new Man();
        man2.setAction("失败");
        persons.add(man2);

        Person woman2 = new Woman();
        woman2.setAction("失败");
        persons.add(woman2);

        Person man3 = new Man();
        man3.setAction("恋爱");
        persons.add(man3);
        Person woman3 = new Woman();
        woman3.setAction("恋爱");
        persons.add(woman3);

        for(Person item : persons) {
            item.getConclusion();
        }

        System.out.println();
        System.out.println("**********************************************");
    }
}

//人抽象类
abstract class Person {
    protected String action;
    public String getAction(){
        return this.action;
    }
    public void setAction(String value){
        this.action = value;
    }
    //得到结论或反应
    public abstract void getConclusion();
}

//男人
class Man extends Person {
    //得到结论或反应
    public void getConclusion() {
        if (action == "成功") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，背后多半有一个伟大的女人。");
        }
        else if (action == "失败") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，闷头喝酒，谁也不用劝。");
        }
        else if (action == "恋爱") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，凡事不懂也要装懂。");
        }
    }
}

//女人
class Woman extends Person {
    //得到结论或反应
    public  void getConclusion() {
        if (action == "成功") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，背后大多有一个不成功的男人。");
        }
        else if (action == "失败") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，眼泪汪汪，谁也劝不了。");
        }
        else if (action == "恋爱") {
            System.out.println(this.getClass().getSimpleName()+this.action+"时，遇事懂也装作不懂。");
        }
    }
}

        粗略看，应该是算，但你不觉得你在'男人'类与'女人'类当中的那些if…else…很是碍眼吗？如果我现在要增加一个'结婚'的状态，你需要改什么？

1.4 用了模式的实现

package code.chapter28.visitor2;

import java.util.ArrayList;

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("**********************************************");
    }
}

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

//人类抽象类
abstract class Person {
    protected String action;

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.action = action;
    }

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

//成功
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()+"时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。");
    }
}



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


//对象结构
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);
        }
    }
}

         "状态"的抽象类和"人"的抽象类：
                "这里关键就在于人只分为男人和女人，这个性别的分类是稳定的，所以可以在状态类中，增加'男人反应'和'女人反应'两个方法，方法个数是稳定的，不会很容易地发生变化。而'人'抽象类中有一个抽象方法'接受'，它是用来获得'状态'对象的。每一种具体状态都继承'状态'抽象类，实现两个反应的方法。"
        具体"状态"类：
        "男人"类和"女人"类：
        "这里需要提一下当中用到一种双分派的技术，首先在客户程序中将具体状态作为参数传递给'男人'类完成了一次分派，然后'男人'类调用作为参数的'具体状态'中的方法'男人反应'，同时将自己（this）作为参数传递进去。这便完成了第二次分派。双分派意味着得到执行的操作决定于请求的种类和两个接收者的类型。'接受'方法就是一个双分派的操作，它得到执行的操作不仅决定于'状态'类的具体状态，还决定于它访问的'人'的类别。"
        "由于总是需要'男人'与'女人'在不同状态的对比，所以我们需要一个'对象结构'类来针对不同的'状态'遍历'男人'与'女人'，得到不同的反应。"       

        "你仔细看看，现在这样做，就意味着，如果我们现在要增加'结婚'的状态来考查'男人'和'女人'的反应。只需要怎么就可以了？"
        "哦，我明白你的意思了，由于用了双分派，使得我只需要增加一个'状态'子类，就可以在客户端调用来查看，不需要改动其他任何类的代码。"
结婚状态类：
        "哈，完美地体现了开放-封闭原则，实在是高呀。这叫什么模式来着？"
        "它应该算是GoF中最复杂的一个模式了，叫作访问者模式。"

1.5 访问者模式

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

        "在这里，Element就是我们的'人'类，而ConcreteElementA和ConcreteElementB就是'男人'和'女人'，Visitor就是我们写的'状态'类，具体的ConcreteVisitor就是那些'成功''失败''恋爱'等状态。至于ObjectStructure就是'对象结构'类了。"
        "哦，怪不得这幅类图我感觉和刚才写的代码类图几乎可以完全对应。"
        "本来我是想直接来谈访问者模式的，但是为什么我突然会愿意和你聊男人和女人的对比呢？原因就在于你说了一句话：'男女对比这么多的原因是人类在性别上就只有男人和女人两类。'而这也正是访问者模式可以实施的前提。"
        "这个前提是什么呢？"
        "你想呀，如果人类的性别不止是男和女，而是可有多种性别，那就意味'状态'类中的抽象方法就不可能稳定了，每加一种类别，就需要在状态类和它的所有下属类中都增加一个方法，这就不符合开放-封闭原则。"
        "哦，也就是说，访问者模式适用于数据结构相对稳定的系统？"
        "对的，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由地演化。"
        "访问者模式的目的是什么？
        "访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。反之，如果这样的系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。"
        "那其实访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。"
        "通常ConcreteVisitor可以单独开发，不必跟ConcreteElementA或ConcreteElementB写在一起。正因为这样，ConcreteVisitor能提高ConcreteElement之间的独立性，如果把一个处理动作设计成ConcreteElementA和ConcreteElementB类的方法，每次想新增'处理'以扩充功能时就得去修改ConcreteElementA和ConcreteElementB了。这也就是你之前写的代码，在'男人'和'女人'类中加了对'成功''失败'等状态的判断，造成处理方法和数据结构的紧耦合。"
        "那访问者的缺点其实也就是使增加新的数据结构变得困难了。"
        "所以GoF四人中的一个作者就说过：'大多时候你并不需要访问者模式，但当一旦你需要访问者模式时，那就是真的需要它了。'事实上，我们很难找到数据结构不变化的情况，所以用访问者模式的机会也就不太多了。这也就是为什么你谈到男人女人对比时我很高兴和你讨论的原因，因为人类性别这样的数据结构是不会变化的。

1.6 访问模式基本代码

        Visitor类，为该对象结构中ConcreteElement的每一个类声明一个Visit操作。
        ConcreteVisitor1和ConcreteVisitor2类：具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，而该算法片断乃是对应于结构中对象的类。
        Element类：定义一个Accept操作，它以一个访问者为参数。
        ConcreteElementA和ConcreteElementB类：具体元素，实现Accept操作。
ObjectStructure类：能枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素。

package code.chapter28.visitor0;

import java.util.ArrayList;

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 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("**********************************************");
    }
}

abstract class Visitor {
    public abstract void visitConcreteElementA(ConcreteElementA concreteElementA);

    public abstract void visitConcreteElementB(ConcreteElementB concreteElementB);
}

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()+"访问");
    }
}

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

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(){ 
    }
}

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);
        }
    }
}

1.7 比上不足，比下有余

        所谓的男人和女人的对比，都是不准确的，我给个答案吧，男人与女人最大的区别就是，比上不足，比下有余。