怎么理解java动态绑定_Java学习笔记之深入理解动态绑定和静态绑定

基本概念

动态绑定和静态绑定是Java中两个重要的概念。首先思考这么一个问题，当一个类中存在方法名相同但参数不同(重载)的函数或同一类层次结构下同一名称的方法(重写)，程序在执行的时候该如何辨别区分呢？这里就需要用到Java中的动态绑定和静态绑定来解决。那么什么是动态绑定和静态绑定呢？

绑定：指一个方法的调用与方法所在的类关联起来

静态绑定：方法在程序编译期进行绑定

动态绑定：方法在程序运行时根据具体对象的类型进行绑定

静态绑定 VS 动态绑定

静态绑定发生在编译期(Compile time)，而动态绑定发生在运行时(Runtime)

private, final and static方法和变量使用静态绑定，而虚函数(virtual methods)则会根据运行时的具体对象进行绑定

静态绑定使用的是类信息，而动态绑定使用的是对象信息

重载方法(overloaded methods)使用的是静态绑定，而重写方法(overridden methods)使用的是动态绑定

虚函数：在Java语言中, 所有的方法默认都是”虚函数”。只有以关键字 final 标记的方法才是非虚函数。虚函数是面向对象编程实现多态的基本手段。

静态绑定示例

例1：

class A {

public void hello(String str) {

System.out.println("a String instance in A");

}

public void hello(Object str) {

System.out.println("a Object instance in A");

}

}

public class BindingDemo {

public static void main(String args[]) {

String str = "";

Object obj = "";

A a = new A();

a.hello(str);

a.hello(obj);

}

}

输出结果：

a String instance in A

a Object instance in A

分析：可以看出，在A中有两个同名但参数不同的方法(重载)，在调用方法a.hello()时，程序会自动根据输入的参数类型来选择具体调用哪个方法，其后的原理就是静态绑定，即在编译期根据参数类型进行静态绑定。

动态绑定实例

例2：

class A {

public void hello() {

System.out.println("hello in A");

}

}

class B extends A {

@Override

public void hello() {

System.out.println("hello in B");

}

}

public class StaticBindingDemo {

public static void main(String args[]) {

A a = new B();

a.hello();

}

}

输出结果：

hello in B

分析：B继承于A，并重写了A中的方法hello()，从结果可知，a.hello()调用的不是A中的hello()，而是B中的hello()，这正是因为程序在运行时发生了动态绑定。同时也说明了重写方法使用的是动态绑定。

相关问题探讨

Stack Overflow上探讨了这么一个问题，具体如下：

class A

{

int x = 5;

}

class B extends A

{

int x = 6;

}

class SubCovariantTest extends CovariantTest

{

public B getObject()

{

System.out.println("sub getobj");

return new B();

}

}

public class CovariantTest {

public A getObject()

{

System.out.println("ct getobj");

return new A();

}

public static void main(String[]args)

{

CovariantTest c1 = new SubCovariantTest();

System.out.println(c1.getObject().x);

}

}

输出结果：

sub getobj

5

看到这样的输出结果，很多人可能会很纳闷，从第一个输出结果sub getobj可以看出调用的是B对象，但从x输出值上看，却是A对象，这是怎么一回事？！先不急着解决这个问题，我们先来看下下面这段程序：

class A

{

int x = 5;

public void doSomething() {

System.out.println("A.doSomething()");

}

}

class B extends A

{

int x = 6;

public void doSomething() {

System.out.println("B.doSomething()");

}

}

public class Main {

public static void main(String args[]) {

A a=new B();

System.out.println(a.x);

a.doSomething();

}

}

输出结果：

5

B.doSomething()

分析：根据前面讲解的静态绑定和动态绑定知识，我们可以清楚的知道，在调用方法a.doSomething()时发生的是动态绑定，故输出结果是B.doSomething()，但当调用a.x时，又发生了些什么呢？！ 这里，我们需要了解一个概念：在Java中，变量(fields)没有多态这个说法，只有方法(methods)有。即变量不存在动态绑定，它是在编译期进行绑定。 在编译期，变量x和方法doSomething()都是和A类进行绑定的，而在程序运行时，doSomething()方法会根据运行的对象类型进行动态绑定，即绑定B类，从而执行的是B类中的doSomething()方法。而x变量不进行动态绑定，所以执行的还是A类中的x变量。 再回到最开始的那个问题：在编译期，c1绑定的是类CovariantTest，则c1.getObject()返回的是类A，故c1.getObject().x指的是A.x；在运行时，c1.getObject()则会根据运行的对象进行动态绑定，即绑定类SubCovariantTest，而c1.getObject().x不会在进行动态绑定，所以x的值还是类A中的x的值。

有人可能对变量x到底是属于哪个类还是很疑惑，那么我们再通过一个例子来进行说明：虽然类A和类B都有一个变量x，但是它们并不是同一个x，既然这样，我们就可以用不同的名称表示这两个变量，将类B中的变量x改为y，具体如下

class A {

int x = 5;

}

class B extends A {

int y = 6;

}

class SubCovariantTest extends CovariantTest {

public B getObject() {

System.out.println("sub getobj");

return new B();

}

}

public class CovariantTest {

public A getObject() {

System.out.println("ct getobj");

return new A();

}

public static void main(String[] args) throws java.lang.Exception {

CovariantTest c1 = new SubCovariantTest();

System.out.println(c1.getObject().y);

}

}

在编译期，如果c1.getObject()返回的是类B，那么上面程序完全没问题，但实际上，会出现以下编译错误。说明，在编译期，c1.getObject()返回的是类A，c1.getObject().x指的是A.x，而且在运行期间不会发生改变。

上面的问题解决了，可能有人还会继续问，那么怎样才能达到变量被重写的效果？我们可以这样实现

class A {

int x = 5;

public int getX() {

return x;

}

public void doSomething() {

System.out.println("A.doSomething()");

}

}

class B extends A {

int x = 6;

public int getX() {

return x;

}

public void doSomething() {

System.out.println("B.doSomething()");

}

}

public class Main {

public static void main(String args[]) {

A a = new B();

System.out.println(a.getX());

a.doSomething();

}

}

输出结果：

6

B.doSomething()

显然，正是利用方法的动态绑定达到变量被重写的效果。

参考资料