1. /*
   
2. 
   
3. 不考虑继承时，对象初始化的过程在视频中都有，考虑继承时，java对象的初始化过程，也可以先用代码验证一下：
   
4. //验证一个有父类的java对象的初始化顺序
   
5. class InitFu{
   
6.     public static String staticFuField = "父类静态变量";
   
7.     public String field="父类成员变量";
   
8.     public int f;
   
9.     static{
   
10.             System.out.println(staticFuField);
    
11.         System.out.println("父类静态初始化块");
    
12.     }// 静态初始化块
    
13.     {
    
14.         System.out.println("父类成员变量默认值："+f);      
    
15.             System.out.println(field);
    
16.         System.out.println("父类构造代码块");
    
17.     }// 初始化块
    
18.     InitFu(){
    
19.         System.out.println("Fu类初始化");
    
20.     }
    
21. }
    
22. public class InitStatic extends InitFu
    
23. {
    
24.         public static String staticField = "子类静态变量";// 静态变量
    
25.     public String field = "子类成员变量";// 变量
    
26.     public int z;
    
27.     static{
    
28.             System.out.println(staticField);
    
29.         System.out.println("子类静态初始化块1，位置在前");
    
30.     }// 静态初始化块
    
31.     {
    
32.         System.out.println("子类成员变量还是默认值："+z);
    
33.             System.out.println(field);
    
34.         System.out.println("子类构造代码块1，位置在前");
    
35.     }// 初始化块
    
36.     static{
    
37.         System.out.println("子类静态初始化块2，位置在后");
    
38.     }// 静态初始化块
    
39.     public InitStatic() {
    
40.             System.out.println("子类构造函数");
    
41.     }// 构造函数
    
42.     public static void main(String[] args) {
    
43.         new InitStatic();
    
44.     }  
    
45.     {
    
46.             //System.out.println(field);
    
47.         System.out.println("子类构造代码块2,位置在后");
    
48.     }// 初始化块
    
49. }
    
50. 运行结果是：
    
51. 父类静态变量
    
52. 父类静态初始化块
    
53. 子类静态变量
    
54. 子类静态初始化块1，位置在前
    
55. 子类静态初始化块2，位置在后
    
56. 父类成员变量默认值：0
    
57. 父类成员变量
    
58. 父类构造代码块
    
59. Fu类初始化
    
60. 子类成员变量还是默认值：0
    
61. 子类成员变量
    
62. 子类构造代码块1，位置在前
    
63. 子类构造代码块2,位置在后
    
64. 子类构造函数
    
65. 这样再分析楼主的代码就容易理解了：
    
66. */
    
67. 
    
68. 
    
69. 
    
70. /*==============================================================
    
71. class Base{
    
72.         private int i = 2;//1.最先执行的
    
73.         
    
74.          Base(){ //2. 第2个顺序执行的，虽然Derved类的构造函数中把super()写在第一行，但不是说是执行到Derived()后才执行父类构造函数
    
75.                 System.out.println("base:"+this.i);  //打印：base:2,因为Base()方法执行是在父类中，所以这里的i是父类的，不是子类的。
    
76.                 this.display(); //这里调用的是子类的display()方法，因为内存中只有一个子类对象，this就是指向子类对象，而且子类复写了display()方法，这是多态特征，调用的是的子类方法。
    
77.         }
    
78.         public void display(){
    
79.                 System.out.println("base display:"+this.i);
    
80.         }
    
81. }
    
82. class Derived extends Base {
    
83.          public int i = 22;
    
84.          {
    
85.                System.out.println(i+"ooooo");
    
86.          }
    
87.          public Derived(){
    
88.                 super(); //
    
89.                 System.out.println(i+"ccccc");
    
90.                 i = 222;        
    
91.          }
    
92.          public void display(){ //3. 从上面的顺序2跳转到这里执行
    
93.                 System.out.println("derived display:"+i); //因为display()这个函数是在父类构造函数中执行的，Base()还没执行完，子类自己的成员变量i还没有显示初始化，还是默认值
    
94.          }
    
95. }
    
96. class TestI {
    
97.         public static void main(String[] args){
    
98.                 new Derived();
    
99.         }
    
100. }
     
101. */

复制代码

谢谢，分享啊。