《JAVA与模式》之访问者模式

时间:2019-11-28 18:58:41
浏览:4
来源:幸运快3_快3口诀_幸运快3口诀

在阎宏博士的《JAVA与模式》一书中开头是一些描述访问者（Visitor）模式的：

　　访问者模式是对象的行为模式。访问者模式的目的是封装一些施加于一种数据价值形式元素之上的操作。一旦那些操作都能不能修改句子，接受之类操作的数据价值形式则可不都能不能保持不变。

　　变量被声明时的类型叫做变量的静态类型(Static Type)，一些人又把静态类型叫做明显类型(Apparent Type)；而变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。比如：

List list = null;
list = new ArrayList();

　　声明了一有三个多多变量list，它的静态类型（也叫明显类型）是List，而它的实际类型是ArrayList。

　　根据对象的类型而对最好的办法进行的确定，一些派发(Dispatch)，派发(Dispatch)又分为一种，即静态派发和动态派发。

　　静态派发(Static Dispatch)位于在编译时期，派发根据静态类型信息位于。静态派发对于亲们来说无须陌生，最好的办法重载一些静态派发。

　　动态派发(Dynamic Dispatch)位于在运行时期，动态派发动态地置换掉某个最好的办法。

　静态派发

　　Java通过最好的办法重载支持静态派发。用墨子骑马的故事作为例子，墨子可不都能不能骑白马之前黑马。墨子与白马、黑马和马的类图如下所示：

　　在之类系统中，墨子由Mozi类代表

public class Mozi {
    
    public void ride(Horse h){
        System.out.println("骑马");
    }
    
    public void ride(WhiteHorse wh){
        System.out.println("骑白马");
    }
    
    public void ride(BlackHorse bh){
        System.out.println("骑黑马");
    }
    
    public static void main(String[] args) {
        Horse wh = new WhiteHorse();
        Horse bh = new BlackHorse();
        Mozi mozi = new Mozi();
        mozi.ride(wh);
        mozi.ride(bh);
    }

}

　　显然，Mozi类的ride()最好的办法是由有三个多多最好的办法重载而成的。这有三个多多最好的办法分别接受马(Horse)、白马(WhiteHorse)、黑马(BlackHorse)等类型的参数。

　　不出在运行时，线程会打印出那些结果呢？结果是线程会打印出相同的两行“骑马”。换言之，墨子发现他所骑的都会马。

　　为那些呢？两次对ride()最好的办法的调用传入的是不同的参数，也一些wh和bh。它们觉得具有不同的真实类型，之前它们的静态类型都会一样的，均是Horse类型。

　　重载最好的办法的派发是根据静态类型进行的，之类派发过程在编译时期就完成了。

　动态派发

　　Java通过最好的办法的重写支持动态派发。用马吃草的故事作为例子，代码如下所示：

public class Horse {
    
    public void eat(){
        System.out.println("马吃草");
    }
}

public class BlackHorse extends Horse {
    
    @Override
    public void eat() {
        System.out.println("黑马吃草");
    }
}

public class Client {

    public static void main(String[] args) {
        Horse h = new BlackHorse();
        h.eat();
    }

}

　　变量h的静态类型是Horse，而真实类型是BlackHorse。之前上边最后一行的eat()最好的办法调用的是BlackHorse类的eat()最好的办法，不出上边打印的一些“黑马吃草”；相反，之前上边的eat()最好的办法调用的是Horse类的eat()最好的办法，不出打印的一些“马吃草”。

　　一些，问题报告的核心一些Java编译器在编译时期无须总爱知道那些代码会被执行，之前编译器仅仅知道对象的静态类型，而我不知道对象的真实类型；而最好的办法的调用则是根据对象的真实类型，而都会静态类型。一些一来，上边最后一行的eat()最好的办法调用的是BlackHorse类的eat()最好的办法，打印的是“黑马吃草”。

　派发的类型

　　一有三个多多最好的办法所属的对象叫做最好的办法的接收者，最好的办法的接收者与最好的办法的参数统称做最好的办法的宗量。比如下面例子中的Test类

public class Test {

    public void print(String str){
        System.out.println(str);
    }
}

　　在上边的类中，print()最好的办法属于Test对象，一些它的接收者也一些Test对象了。print()最好的办法有一有三个多多参数是str,它的类型是String。

　　根据派发可不都能不能基于哪几个种宗量，可不都能不能将面向对象的语言划分为单派发语言(Uni-Dispatch)和多派发语言(Multi-Dispatch)。单派发语言根据一有三个多多宗量的类型进行对最好的办法的确定，多派发语言根据多于一有三个多多的宗量的类型对最好的办法进行确定。

　　C++和Java均是单派发语言，多派发语言的例子包括CLOS和Cecil。按照一些的区分，Java一些动态的单派发语言，之前之类语言的动态派发仅仅会考虑到最好的办法的接收者的类型，同去又是静态的多派发语言，之前之类语言对重载最好的办法的派发会考虑到最好的办法的接收者的类型以及最好的办法的所有参数的类型。

　　在一有三个多多支持动态单派发的语言上边，有三个多多多条件决定了一有三个多多请求会调用哪一有三个多多操作：一是请求的名字，一些接收者的真实类型。单派发限制了最好的办法的确定过程，使得只能一有三个多多宗量可不都能不能被考虑到，之类宗量通常一些最好的办法的接收者。在Java语言上边，之前一有三个多多操作是作用于某个类型不明的对象上边，不出对之类对象的真实类型测试仅会位于一次，之类些动态的单派发的价值形式。

　双重派发

　　一有三个多多最好的办法根据有三个多多宗量的类型来决定执行不同的代码，之类些“双重派发”。Java语言不支持动态的多派发，也就因为Java不支持动态的双派发。之前通过使用设计模式，也可不都能不能在Java语言里实现动态的双重派发。

　　在Java中可不都能不能通过两次最好的办法调用来达到两次派发的目的。类图如下所示：

　　在图包含三个多多多对象，左边的叫做West，右边的叫做East。现在West对象首先调用East对象的goEast()最好的办法，并将它当事人传入。在East对象被调用时，立即根据传入的参数知道了调用者是谁，于是反过来调用“调用者”对象的goWest()最好的办法。通过两次调用将线程控制权轮番交给有三个多多对象，其时序图如下所示：

　　一些就老出了两次最好的办法调用，线程控制权被有三个多多对象像传球一样，首先由West对象传给了East对象，之前又被返传给了West对象。

　　之前仅仅返传了一下球，无须能处里双重派发的问题报告。关键是怎么能不能利用这两次调用，以及Java语言的动态单派发功能，使得在之类传球的过程中，都都能不能触发两次单派发。

　　动态单派发在Java语言中是在子类重写父类的最好的办法时位于的。换言之，West和East都都能不能分别置身于当事人的类型等级价值形式中，如下图所示：

　　源代码

　　West类

public abstract class West {
    
    public abstract void goWest1(SubEast1 east);
    
    public abstract void goWest2(SubEast2 east);
}

　　SubWest1类

public class SubWest1 extends West{
    
    @Override
    public void goWest1(SubEast1 east) {
        
        System.out.println("SubWest1 + " + east.myName1());
    }
    
    @Override
    public void goWest2(SubEast2 east) {
        
        System.out.println("SubWest1 + " + east.myName2());
    }
}

　　SubWest2类

public class SubWest2 extends West{
    @Override
    public void goWest1(SubEast1 east) {
        
        System.out.println("SubWest2 + " + east.myName1());
    }
    
    @Override
    public void goWest2(SubEast2 east) {
        
        System.out.println("SubWest2 + " + east.myName2());
    }
}

　　East类

public abstract class East {

    public abstract void goEast(West west);
}

　　SubEast1类

public class SubEast1 extends East{
    @Override
    public void goEast(West west) {
        west.goWest1(this);
    }
    
    public String myName1(){
        return "SubEast1";
    }
}

　　SubEast2类

public class SubEast2 extends East{
    @Override
    public void goEast(West west) {
        west.goWest2(this);
    }
    
    public String myName2(){
        return "SubEast2";
    }
}

　　客户端类

public class Client {

    public static void main(String[] args) {
        //组合1
        East east = new SubEast1();
        West west = new SubWest1();
        east.goEast(west);
        //组合2
        east = new SubEast1();
        west = new SubWest2();
        east.goEast(west);
    }

}

　　运行结果如下

SubWest1 + SubEast1

SubWest2 + SubEast1

　　系统运行时，会首先创建SubWest1和SubEast1对象，之前客户端调用SubEast1的goEast()最好的办法，并将SubWest1对象传入。之前 SubEast1对象重写了其超类East的goEast()最好的办法，之前，之类之前就位于了一次动态的单派发。当SubEast1对象接到调用时，会从参数中得到SubWest1对象，一些它就立即调用之类对象的goWest1()最好的办法，并将当事人传入。之前 SubEast1对象有权确定调用哪一有三个多多对象，之前，在此时又进行一次动态的最好的办法派发。

　　之类之前 SubWest1对象就得到了SubEast1对象。通过调用之类对象myName1()最好的办法，就可不都能不能打印出当事人的名字和SubEast对象的名字，其时序图如下所示：

　　之前这有三个多多名字一有三个多多来自East等级价值形式，一些来自West等级价值形式中，之前，它们的组合式是动态决定的。之类些动态双重派发的实现机制。

　　访问者模式适用于数据价值形式相对未定的系统，它把数据价值形式和作用于价值形式上的操作之间的耦合解脱开，使得操作集合可不都能不能相对自由地演化。访问者模式的简略图如下所示：

　　数据价值形式的每一有三个多多节点都可不都能不能接受一有三个多多访问者的调用，此节点向访问者对象传入节点对象，而访问者对象则反过来执行节点对象的操作。一些的过程叫做“双重派发”。节点调用访问者，将它当事人传入，访问者则将某算法针对此节点执行。访问者模式的示意性类图如下所示：

　　访问者模式涉及到的角色如下：

　　●　　抽象访问者(Visitor)角色：声明了一有三个多多之前多个最好的办法操作，形成所有的具体访问者角色都能不能实现的接口。

　　●　　具体访问者(ConcreteVisitor)角色：实现抽象访问者所声明的接口，也一些抽象访问者所声明的各个访问操作。

　　●　　抽象节点(Node)角色：声明一有三个多多接受操作，接受一有三个多多访问者对象作为一有三个多多参数。

　　●　　具体节点(ConcreteNode)角色：实现了抽象节点所规定的接受操作。

　　●　　价值形式对象(ObjectStructure)角色：有如下的责任，可不都能不能遍历价值形式中的所有元素；之前都能不能，提供一有三个多多高层次的接口让访问者对象可不都能不能访问每一有三个多多元素；之前都能不能，可不都能不能设计成一有三个多多复合对象之前一有三个多多聚集，如List或Set。

　　源代码

　　可不都能不能看后，抽象访问者角色为每一有三个多多具体节点都准备了一有三个多多访问操作。之前有三个多多多节点，之前，对应都会有三个多多访问操作。

public interface Visitor {
    /**
     * 对应于NodeA的访问操作
     */
    public void visit(NodeA node);
    /**
     * 对应于NodeB的访问操作
     */
    public void visit(NodeB node);
}

　　具体访问者VisitorA类

public class VisitorA implements Visitor {
    /**
     * 对应于NodeA的访问操作
     */
    @Override
    public void visit(NodeA node) {
        System.out.println(node.operationA());
    }
    /**
     * 对应于NodeB的访问操作
     */
    @Override
    public void visit(NodeB node) {
        System.out.println(node.operationB());
    }

}

　　具体访问者VisitorB类

public class VisitorB implements Visitor {
    /**
     * 对应于NodeA的访问操作
     */
    @Override
    public void visit(NodeA node) {
        System.out.println(node.operationA());
    }
    /**
     * 对应于NodeB的访问操作
     */
    @Override
    public void visit(NodeB node) {
        System.out.println(node.operationB());
    }

}

　　抽象节点类

public abstract class Node {
    /**
     * 接受操作
     */
    public abstract void accept(Visitor visitor);
}

　　具体节点类NodeA

public class NodeA extends Node{
    /**
     * 接受操作
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    /**
     * NodeA特有的最好的办法
     */
    public String operationA(){
        return "NodeA";
    }

}

　　具体节点类NodeB

public class NodeB extends Node{
    /**
     * 接受最好的办法
     */
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
    /**
     * NodeB特有的最好的办法
     */
    public String operationB(){
        return "NodeB";
    }
}

　　价值形式对象角色类，之类价值形式对象角色持有一有三个多多聚集，并向外界提供add()最好的办法作为对聚集的管理操作。通过调用之类最好的办法，可不都能不能动态地增加一有三个多多新的节点。

public class ObjectStructure {
    
    private List<Node> nodes = new ArrayList<Node>();
    
    /**
     * 执行最好的办法操作
     */
    public void action(Visitor visitor){
        
        for(Node node : nodes)
        {
            node.accept(visitor);
        }
        
    }
    /**
     * 换成一有三个

多多新元素
     */
    public void add(Node node){
        nodes.add(node);
    }
}

　　客户端类

public class Client {

    public static void main(String[] args) {
        //创建一有三个

多多价值形式对象
        ObjectStructure os = new ObjectStructure();
        //给价值形式增加一有三个

多多节点
        os.add(new NodeA());
        //给价值形式增加一有三个

多多节点
        os.add(new NodeB());
        //创建一有三个

多多访问者
        Visitor visitor = new VisitorA();
        os.action(visitor);
    }

}

　　确觉得之类示意性的实现里并不出老出一有三个多多复杂性的具有多个树枝节点的对象树价值形式，之前，在实际系统中访问者模式通常是用来处里复杂性的对象树价值形式的，之前访问者模式可不都能不能用来处里跨很多个等级价值形式的树价值形式问题报告。这正是访问者模式的功能强大之处。

　　准备过程时序图

　　首先，之类示意性的客户端创建了一有三个多多价值形式对象，之前将一有三个多多新的NodeA对象和一有三个多多新的NodeB对象传入。

　　其次，客户端创建了一有三个多多VisitorA对象，并将此对象传给价值形式对象。

　　之前，客户端调用价值形式对象聚集管理最好的办法，将NodeA和NodeB节点加入到价值形式对象中去。

　　最后，客户端调用价值形式对象的行动最好的办法action()，启动访问过程。

　　访问过程时序图

　　价值形式对象会遍历它当事人所保存的聚集中的所有节点，在本系统中一些节点NodeA和NodeB。首先NodeA会被访问到，之类访问是由以下的操作组成的：

　　（1）NodeA对象的接受最好的办法accept()被调用，并将VisitorA对象一种传入；

　　（2）NodeA对象反过来调用VisitorA对象的访问最好的办法，并将NodeA对象一种传入；

　　（3）VisitorA对象调用NodeA对象的特有最好的办法operationA()。

　　从而就完成了双重派发过程，接着，NodeB会被访问，之类访问的过程和NodeA被访问的过程是一样的，这里不再叙述。

　　●　　好的扩展性

　　都都能不能在不修改对象价值形式中的元素的请况下，为对象价值形式中的元素换成新的功能。

　　●　　好的复用性

　　可不都能不能通过访问者来定义整个对象价值形式通用的功能，从而提高复用程度。

　　●　　分离无关行为

　　可不都能不能通过访问者来分离无关的行为，把相关的行为封塞进同去，构成一有三个多多访问者，一些每一有三个多多访问者的功能都比较单一。

　　●　　对象价值形式变化很困难

　　不适用于对象价值形式中的类总爱变化的请况，之前对象价值形式位于了改变，访问者的接口和访问者的实现都会位于相应的改变，代价太高。

　　●　　破坏封装

　　访问者模式通常都能不能对象价值形式开放内部数据给访问者和ObjectStructrue，这破坏了对象的封装性。