问题
先来看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."<init>":()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."<init>":()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."<init>":()V
4: return
public test.A getObject();
Code:
0: new #2 // class test/A
3: dup
4: invokespecial #3 // Method test/A."<init>":()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."<init>":()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对象运行时的内存结构
