Java中的静态绑定和动态绑定

问题

先来看stack overflow上的一个问题：

import java.util.*;
import java.lang.*;
import java.io.*;

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

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().x);
    }
}

当我们执行CovariantTest中的main()方法时，输出结果会是什么？
答案是：

sub getobj
5

这不科学！既然c1.getObject()执行的是SubCovariantTest中的getObject()方法，那么应该返回的是B对象，所以应该输出6才对啊。
这个解释听上去很有道理，但忽略了Java中的静态绑定和动态绑定的知识。

静态绑定 vs 动态绑定

• 绑定：绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。
• 静态绑定：程序运行前方法已被绑定。即Java中编译期进行的绑定。
• 动态绑定：程序运行时根据具体对象的类型进行绑定。

Java中程序分为编译和解释两个阶段。
也就是说，Java文件被编译成class文件时，已经对其中的方法和域根据类信息进行了一次绑定（静态绑定）。
而运行时方法又会根据运行时对象信息进行另外一次绑定（动态绑定），也就说我们常说的多态

值得注意的是：Java中private,final,static方法以及域都是静态绑定，这也是Java中域不能被重写只能被隐藏的原因。

进一步理解两种绑定

什么？你还是不明白这两种绑定！没关系，我们来点更详细的Demo

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

Output:

5
B.doSomething()

结果在意料当中，我们来看下反编译Main.class文件后的信息：

//javap -c Main
Compiled from "Main.java"
public class test.Main {
  public test.Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class test/B
       3: dup
       4: invokespecial #3                  // Method test/B."":()V
       7: astore_1
       8: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      11: aload_1
      12: getfield      #5                  // Field test/A.x:I
      15: invokevirtual #6                  // Method java/io/PrintStream.println:(I)V
      18: aload_1
      19: invokevirtual #7                  // Method test/A.doSomething:()V
      22: return
}

通过12：和19：后的注释我们可以知道，编译后的class文件中，域x和方法doSomething都是和A类绑定在了一起。而在程序执行时，doSomething方法会再根据运行的对象类型进行第二次的动态绑定，从执行了B类中的方法。

解答问题

回到最开始问题。
我们反编译下CovariantTest.class文件：

//javap -c CovariantTest
Compiled from "CovariantTest.java"
public class test.CovariantTest {
  public test.CovariantTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public test.A getObject();
    Code:
       0: new           #2                  // class test/A
       3: dup
       4: invokespecial #3                  // Method test/A."":()V
       7: areturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #4                  // class test/SubCovariantTest
       3: dup
       4: invokespecial #5                  // Method test/SubCovariantTest."":()V
       7: astore_1
       8: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      11: aload_1
      12: invokevirtual #7                  // Method getObject:()Ltest/A;
      15: getfield      #8                  // Field test/A.x:I
      18: invokevirtual #9                  // Method java/io/PrintStream.println:(I)V
      21: return
}

从12:和15:可以看出，在编译期，c1跟类CovariantTest绑定在一起，所以c1.getObject()编译后认为是类A，c1.getObject().x编译后便成为了A.x。
又因为Java中域是静态绑定的，所以程序运行时便不会根据运行时对象类型来确定，所有最后输出了5

两种绑定各自的优缺点

静态绑定能够让我们在编译时就发现代码的许多错误，而且也提高了程序的运行效率。动态绑定的好处在于牺牲了运行效率但实现了多态

这里引用 Java静态绑定与动态绑定中的一段话来总结：

java因为什么要对属性要采取静态的绑定方法。这是因为静态绑定是有很多的好处，它可以让我们在编译期就发现程序中的错误，而不是在运行期。这样就可以提高程序的运行效率！而对方法采取动态绑定是为了实现多态，多态是java的一大特色。多态也是面向对象的关键技术之一，所以java是以效率为代价来实现多态这是很值得的。

最后的啰嗦

这个问题我起初在CSDN上提问：stackoverflow上面的java的域不能“重写”问题，感谢caozhy 的回答。虽然当时还是有些不理解。过了段时间开始有点明白，所以写了这篇博客作总结。水平有限，仅供参考。

关于动态绑定更详细的实现机制可以看 Simple Java—Compiler and JVM（一）Java对象运行时的内存结构

参考：
Java中的静态绑定和动态绑定详细介绍
Java静态绑定与动态绑定