Java類和對象的初始化順序
本文摘錄于http://blog.csdn.net/socoolfj/archive/2006/05/23/750425.aspx，并修改例子的代碼，加上自己的見解。
類裝載步驟
在Java中，類裝載器把一個類裝入Java虛擬機中，要經過三個步驟來完成：裝載、鏈接和初始化，其中鏈接又可以分成校驗、準備和解析三步，除了解析外，其它步驟是嚴格按照順序完成的，各個步驟的主要工作如下：
裝載：查找和導入類或接口的二進制數據；
鏈接：執行下面的校驗、準備和解析步驟，其中解析步驟是可以選擇的；
校驗：檢查導入類或接口的二進制數據的正確性；
準備：給類的靜態變量分配并初始化存儲空間；
解析：將符號引用轉成直接引用；
初始化：激活類的靜態變量的初始化Java代碼和靜態Java代碼塊。
其中 初始化（initialization）包含兩部分：
1.類的初始化（initialization class & interface）
2.對象的創建（creation of new class instances）。
因為類的初始化其實是類加載（loading of classes）的***一步，所以很多書中把它歸結為“對象的創建”的***步。其實只是看問題的角度不同而已。為了更清楚的理解，這里還是分開來。
順序：
因為類的加載肯定是***步的，所以類的初始化在前。大體的初始化順序是：
類初始化 -> 子類構造函數 -> 父類構造函數 -> 實例化成員變量 -> 繼續執行子類構造函數的語句
下面結合例子，具體解釋一下。
1. 類的初始化（Initialization classes and interfaces）
其實很簡單，具體來說有：
（a）初始化類（initialization of class），是指初始化static field 和執行static初始化塊。
- public class Demo{
- //初始化static field,
- //其中= "initialization static field"又叫做static field initializer
- private static String str = "initialization static field";
- //初始化塊，又叫做static initializer，或 static initialization block
- static {
- System.out.println("This is static initializer");
- }
- }
btw，有些書上提到static initializer 和 static field initializer 的概念，與之對應的還有 instance initializer 和 instance variable initializer。例子中的注釋已經解釋了其含義。
（b）初始化接口（initialization of interface），是指初始化定義在該interface中的field。
*注意*
1. initialization classes 時，該class的superclass 將首先被初始化，但其實現的interface則不會。
initialization classes 時，該class的superclass，以及superlcass的superclass 會首先被遞歸地初始化，一直到java.lang.Object為止。但initialiazation interface的時候，卻不需如此，只會初始化該interface本身。
2. 對于由引用類變量（class field）所引發的初始化，只會初始化真正定義該field的class。
3. 如果一個static field是編譯時常量（compile-time constant），則對它的引用不會引起定義它的類的初始化。
為了幫助理解***兩點，請試試看下面的例子：
Initialization類
- public class Initialization {
- static {
- System.out.println("Initialization Main class");
- }
- public static void main(String[] args) {
- System.out.println(Sub.y);
- System.out.println(Sub.x);
- System.out.println(Sub.z);
- }
- }
Sub類
- public class Sub extends Super {
- public static final int y = 2005;
- public static int z;
- static {
- System.out.println("Initialization Sub");
- }
- }
Super類
- public class Super {
- public static int x = 2006;
- static {
- System.out.println("Initialization Super");
- }
- }
輸入結果
Initialization Main class 2005 Initialization Super 2006 Initialization Sub 0
從這個結果可以看到，
- static塊在類中會先執行；(實際上是先加載static成員變量，然后是static代碼塊)
- static 的final變量不會引起類的初始化；
- 子類Sub引用父類Super里面的變量，就會引起父類的初始化，但不會引起子類的初始化；
- static的成員變量也有默認值。
2. 對象的創建（creation of new class instances）
看例子來說明：
InitializationOrder類
- public class InitializationOrder {
- public static void main(String[] args) {
- SubClass sb = new SubClass();
- }
- }
SuperClass類
- public class SuperClass{
- static {
- System.out.println("SuperClass static");
- }
- SuperClass(String str){
- System.out.println(str);
- }
- }
Interface類
- interface Interface{
- static SuperClass su = new SuperClass("Interface new SuperClass");
- }
SubClass類
- public class SubClass extends SuperClass implements Interface{
- static {
- System.out.println("SubClass static");
- }
- private SuperClass su = new SuperClass("initialization variable");
- SubClass() {
- super("super");
- new SuperClass("new SuperClass");
- }
- }
輸出結果
SuperClass static SubClass static super initialization variable new SuperClass
解釋一下：
1) Java虛擬機要執行InitializationOrder類中的static 方法main()，這引起了類的初始化。開始初始化InitializationOrder類。具體的步驟略去不說。
2) InitializationOrder類初始化完畢后，開始執行main()方法。語句SubClass sb = new SubClass()將創建一個SubClass對象。加載類SubClass后對其進行類初始化，因為Subclass有一個父類SuperClass，所以先初始化SuperClass類。于是看到輸出“SuperClass static”。
3) SuperClass類初始化完畢后，開始初始化SubClass類，輸出“SubClass static”。
4) 至此，類的加載工作全部完成。開始進入創建SubClass的對象過程。先為SubClass類和其父類SuperClass類分配內存空間，這時Super su 被賦值為null。
5) 執行構造函數SubClass()，執行super(), 調用父類的構造函數，輸出“super”。
6) 初始化SubClass類的成員變量su，輸出“initialization variable”。
7) 繼續執行構造函數的剩余部分，執行new SuperClass("new SuperClass")，輸出“new SuperClass”，這時Super su 被賦值新建對象的引用。
8) 而SubClass雖然實現了接口Interface，但是初始化它的時候并不會引起接口的初始化，所以接口Interface中的static SuperClass su = new SuperClass("Interface new SuperClass")自始至終都沒有被執行到。
所以對象的創建，具體步驟如下：
(1) 所有的成員變量—包括該類，及它的父類中的成員變量--被分配內存空間，并賦予默認值。（這里是***次初始化成員變量）
(2) 為所調用的構造函數初始化其參數變量。（如果有參數）
(3) 如果在構造函數中用this 調用了同類中的其他構造函數，則按照步驟(2)~(6)去處理被調用到的構造函數。
(4) 如果在構造函數中用super調用了其父類的構造函數，則按照步驟(2)~(6)去處理被調用到的父類構造函數。
(5) 按照書寫順序，執行instance initializer 和 instance variable initializer來初始化成員變量。（這里是第二次初始化成員變量）
(6) 按照書寫順序，執行構造函數的其余部分。
*******************
總結：
從類的初始化和對象的創建步驟，可以知道，一個類是先初始化static的變量和static句塊，然后在分配該類以及父類的成員變量的內存空間，賦予默認值，然后開始調用構造函數。而子類和父類之間，則先初始化和創建父類，然后在初始化和創建子類的。
原文鏈接：http://android.blog.51cto.com/268543/384500
【編輯推薦】
- Think in Java之構造器的真正調用順序
- 用Java編寫你自己的簡單HTTP服務器
- 拯救Java程序猿的神器：Play Framework
- 有可能挑戰Java優勢的四種技術
- Think in Java之斐波那契數列
