ublic class Test01 {

/**
* @param args
*/
public static void main(String[] args) {
B b=new B();
}
}

class A{
int num=5;
A(){
show();
}
public void show(){
  System.out.println("A"+num);
}
}

class B extends A{
int num=10;
B(){
     show();       
}
public void show(){
System.out.println("B"+num);
}
}
结果为：
B0
B10
求讲解

1. 
   
2. 
   
3. /**
   
4. * 这个问题主要是理解对象初始化的顺序，同时注意隐式this
   
5. */
   
6. public class Test {
   
7.        
   
8.         //这里建立子类对象，下面数字代表执行顺序
   
9.         public static void main(String[] args) {
   
10.                 B b = new B(); //---------建立对象，走其构造----1
    
11.         }
    
12. }
    
13. 
    
14. class A {
    
15.         int num = 5;
    
16. 
    
17.         A() {
    
18.                 show(); //------子类对象调用this.show方法，由于子类覆写了。
    
19.                 //所以走子类，同时子类中有自己num.
    
20.                 //但这个时候，构造函数还未初始完，所以子类成员变量的值还是默认的0.------3
    
21.         }
    
22. 
    
23.         public void show() {
    
24.                 System.out.println("A" + num);
    
25.         }
    
26. }
    
27. /*
    
28. * 构造函数初始化完，之后才到非静态成员变量的初始化。
    
29. */
    
30. 
    
31. class B extends A {
    
32.         int num = 10;
    
33.         B() {
    
34.                 super();//--隐式super-----即在构造的时候先走父类---2
    
35.                 show();
    
36.         }
    
37.         public void show() {
    
38.                 System.out.println("B" + num);
    
39.         }
    
40. }
    

复制代码

1. 
   
2. public class ExtendsTest
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 B b = new B();
   
7.         }
   
8. }
   
9. 
   
10. class A
    
11. {
    
12.         int num = 5;
    
13.        
    
14.         A()
    
15.         {
    
16.                 show();
    
17.         }
    
18.        
    
19.         public void show()
    
20.         {
    
21.                 System.out.println("A"+num);
    
22.         }
    
23. }
    
24. 
    
25. class B extends A
    
26. {
    
27.         int num = 10;
    
28.        
    
29.         B()
    
30.         {
    
31.                 super();
    
32.                 show();
    
33.                 return;
    
34.         }
    
35.        
    
36.         public void show()
    
37.         {
    
38.                 System.out.println("B"+num);
    
39.         }
    
40. }
    

复制代码

有看到我改的B的构造函数么，首先，你要明确 在子类中构造函数肯定会访问 父类的空参的构造函数（指定的父类的构造函数另当别论了），也就是 super()这一步，当A B 加载进内存时 在代码区域，你new了一个B 时会访问到A的空参的构造函数，这个时候堆内存中 B的情况 是 num并没有显示初始化，而是默认初始化，也就是说这个时候 B的 num 的值默认是 0，此时访问到的A的构造函数中调用了 show()方法，而在B中已经重写了A的此方法，也就是说其实调用的是B的show()方法，这个时候输出自然是 B0 了，只有当 super() 即父类初始化完毕了，才进行子类的成员变量的显示初始化， super() 就是一个分水岭，这一步结束了，num的值立刻就被显示初始化变成 10 （这一步的显示初始化紧紧跟着super()），之后再调用 show()，这就不用多说了吧， 输出 B10,是一定的啦。。呼呼，，
  真心欢迎大神指出理解中的错处，谢谢了