java动态绑定

静态绑定

方法的重载在调用之前已经确认了方法的使用，并不会由运行时的类型来决定。即说的是在一个类里面方法的调用是由句柄在编译期就已经确定了使用哪一个方法。

采用java的访问者模式来确定这个特性：

Visitor实现类:

package com.visitor;

/**
 * Created by zooy on 2015/12/14.
 */
public class AVisitor implements Visitor {

    public void doHandle(Node node) {
        node.accept(this);
    }
}

Node实现类：

package com.visitor;

/**
 * Created by zooy on 2015/12/14.
 */
public class ANode implements Node {

    public void accept(Visitor visitor) {

        System.out.println("Visitor is coming");
    }

    public void accept(AVisitor visitor) {

        System.out.println("AVisitor is coming");
    }
}

Client类：

package com.visitor;

/**
 * Created by zooy on 2015/12/14.
 */
public class Client {

    public static void main(String[] args) {
        Visitor visitor = new AVisitor(); 
        AVisitor aVisitor = new AVisitor();
        Node node = new ANode();

        node.accept(visitor);
        node.accept(aVisitor);

    }
}

上面实现的类都是AVisitor,但是句柄一个是Visitor，一个是AVisitor。

打印的结果是：

Visitor is coming
AVisitor is coming

可以预见的是这里体现了java的静态绑定。

动态绑定

Client类:

package com.visitor;

/**
 * @author dongbin.yu
 * @version 1.0.0
 * @since 2015/12/15
 */
public class Client {

    public static void main(String[] args) {
        Visitor visitor = new AVisitor();
        AVisitor aVisitor = new AVisitor();
        Node node = new ANode();

        visitor.doHandle(node);
        aVisitor.doHandle(node);

    }
}

我的这个例子并不是完整的访问者模式，还缺少结构对象类。但是已经可以表示双重分派的作用了。打印的结果是：

AVisitor is coming
AVisitor is coming

已经忽略了句柄的静态绑定。

node.accept(this);

是java中类的覆盖（重写）是动态绑定时调用不同方法，已经动态确定了这个类的类型，在作为this对象传入就可以在运行期动态确定对象的类型。