java类的初始化顺序

下面的程序说明子父类中成员变量的构造顺序

  abstract   class  SupConstruction
... {
SupConstruction()
...{
System.out.println("SupConstruction constructed!");
con(); 
System.out.println("con"); 
}
abstract void con();//虚拟函数
}

public   class  Construction  extends  SupConstruction // 继承虚拟类
... {
int i =9;
Construction()
...{
super(); //调用构造函数
System.out.println("Construction constructed "+i);
}

public void con()//超越虚拟方法
...{
System.out.println("Con "+i);
}
public static void main(String [] args)
...{
Construction c = new Construction();//实例化.
}
}

 

输出结果：

SupConstruction constructed!
Con 0
con
Construction constructed 9

其中的Con 0说明在此时i已经被声明，并且被赋上初值（或者说该变量所占的内存空间被清空）。同时也说明i=9，还没有被执行。上面程序的顺序是这样的：当new 一个Construction的时候，调用Construction的构造函数。然后进入父类的构造函数。而在进入Construction的构造函数之前或许int i已经被执行（这点以后还会说明为什么），但i=9没有被执行。进入父类的构造函数函数后打印SupConstruction constructed!，然后调用自己的虚方法。因为多态的机制，函数将调用子类的同名方法。在那里打印Con 0。然后返回到父类打印con，再返回子类的构造函数打印Construction constructed 9。结束构造。

下面讲讲为什么说进入Construction的构造函数之前或许int i已经被执行。看下面的例子：

 

class  Test 
... {
    int t1 = 3;
    static int t2 = 4;
    static
    ...{
        System.out.println("Static block "+"t2:"+t2);
    }

    public Test()
    ...{
        System.out.println("Construct:t1:"+t1+"t2:"+t2);    
        t1=30;
        t2 = 40;
    }
    ...{
        
        t2 = 9;
        System.out.println("nonstatic,t1:"+t1+"t2:"+t2);    

    }    
    public static void TestClass()
    ...{
        System.out.println("Static Method:"+"t2:"+t2);
    }
    
}

public   class  Life
... {
    public static void main(String [] args)
    ...{
        Test.TestClass();
        Test t = new Test();
        
    }
    
}

打印结果：

Static block t2:4
Static Method:t2:4
nonstatic,t1:3t2:9
Construct:t1:3t2:9

这说明在执行构造函数之前nonstatic块就已经被执行。而且看出了初始化顺序static变量->static块->非static变量->非static块->构造函数。但是不是真的是这样？看下面的例子：

 

class  SupTest
... {
    int st1 = 12;
    static int st2 = 19;
    public SupTest(int x)
    ...{
        st1 = x;
    }
}

class  Test  extends  SupTest
... {
    int t1 = 3;
    static int t2 = 4;
    static
    ...{
        System.out.println("super static : "+"t2:"+SupTest.st2);

        System.out.println("Static block "+"t2:"+t2);
    }

    public Test()
    ...{
        super(t1);
        System.out.println("Construct:t1:"+t1+"t2:"+t2);    
        t1=30;
        t2 = 40;
    }
    ...{
        t2 = 9;
        System.out.println("nonstatic,t1:"+t1+"t2:"+t2);    

    }    
    public static void TestClass()
    ...{
        System.out.println("Static Method:"+"t2:"+t2);
    }
    
}

public   class  Life
... {
    public static void main(String [] args)
    ...{
        Test.TestClass();
        Test t = new Test();
        
    }
    
}

打印结果：

Life.java:24: 无法在调用父类型构造函数之前引用 t1
                super(t1);
                      ^
1 错误

可惜编译的时候就报错。然后将  super(t1);改为  super(t2)编译运行成功。

这说明在调用父类构造函数前，子类的t1并没有声明并被缺省初始化。然后对于第一个程序在子类Construction 中添加非静态块打印i;得到打印结果：

SupConstruction constructed!
Con 0
con
9
Construction constructed 9

这就道出了真正的构造顺序：(结合static只属于类的经验)

加载class路径->static变量初始化->static块->进入子类构造函数->进入父类构造函数->父类虚方法下传->子类非static变量声明并清空相应的内存空间->多态机制，子类同名函数调用->父类构造函数退出->子类非static变量赋值->子类非static块调用->子类构造函数退出->对象构造完成。