2015-02-22 21:32

[轉載] Java 類靜態域，非靜態域，構造函數的初始化順序

轉載自：java类静态域、块，非静态域、块，构造函数的初始化顺序 - 艾妮 - ITeye技术网站

面試的時候，經常會遇到這樣的考題：給你兩個類的程式，它們之間是繼承的關系，每個類裡只有建構子方法和一些變數，建構子裡可能還有一段程式對變數值進行了某種運算，另外還有一些將變數值輸出到控制台的程式，然後讓我們判斷輸出的
結果。這實際上是在考查我們對於繼承情況下類的初始化順序的了解。

我們大家都知道，對於靜態變數、靜態初始化、變數、初始化、建構子，它們的初始化順序以此是：
(靜態變數、靜態初始化) > (變數、初始化) > 建構子

我們也可以通過下面的測試程式來驗證這一點：
原始碼
  1. public class InitialOrderTest { 
  2.    // 靜態變數 
  3.    public static String staticField = "靜態變數"; 
  4.  
  5.    // 變數 
  6.    public String field = "變數"; 
  7.  
  8.    // 靜態初始化 
  9.    static { 
  10.        System.out.println(staticField); 
  11.        System.out.println("靜態初始化"); 
  12.    } 
  13.  
  14.    // 初始化 
  15.    { 
  16.        System.out.println(field); 
  17.        System.out.println("初始化"); 
  18.    } 
  19.  
  20.    // 建構子 
  21.    public InitialOrderTest() { 
  22.        System.out.println("建構子"); 
  23.    } 
  24.  
  25.    public static void main(String[] args) { 
  26.        new InitialOrderTest(); 
  27.    } 
  28. } 

運行以上程式，我們會得到如下的輸出結果：
  1. 靜態變數 
  2. 靜態初始化 
  3. 變數 
  4. 初始化 
  5. 建構子 

這與上文中說的完全符合。



那麼對於繼承情況下又會怎樣呢？我們仍然以一段測試程式來獲取最終結果：
原始碼
  1. class Parent { 
  2.    // 靜態變數 
  3.    public static String p_StaticField = "父--靜態變數"; 
  4.  
  5.    // 變數 
  6.    public String p_Field = "父--變數"; 
  7.  
  8.    // 靜態初始化 
  9.    static { 
  10.        System.out.println(p_StaticField); 
  11.        System.out.println("父--靜態初始化"); 
  12.    } 
  13.  
  14.    // 初始化 
  15.    { 
  16.        System.out.println(p_Field); 
  17.        System.out.println("父--初始化"); 
  18.    } 
  19.    // 建構子 
  20.    public Parent() { 
  21.        System.out.println("父--建構子"); 
  22.    } 
  23. } 
  24.  
  25.  
  26. public class SubClass extends Parent { 
  27.  
  28.    // 靜態變數 
  29.    public static String s_StaticField = "子--靜態變數"; 
  30.  
  31.    // 變數 
  32.    public String s_Field = "子--變數"; 
  33.  
  34.    // 靜態初始化 
  35.    static { 
  36.        System.out.println(s_StaticField); 
  37.        System.out.println("子--靜態初始化"); 
  38.    } 
  39.  
  40.    // 初始化 
  41.    { 
  42.        System.out.println(s_Field); 
  43.        System.out.println("子--初始化"); 
  44.    } 
  45.  
  46.    // 建構子 
  47.    public SubClass() { 
  48.        System.out.println("子--建構子"); 
  49.    } 
  50.  
  51.  
  52.    public static void main(String[] args) { 
  53.        new SubClass(); 
  54.    } 
  55. } 

運行一下上面的程式，結果馬上呈現在我們的眼前：
  1. 父--靜態變數 
  2. 父--靜態初始化 
  3. 子--靜態變數 
  4. 子--靜態初始化 
  5. 父--變數 
  6. 父--初始化 
  7. 父--建構子 
  8. 子--變數 
  9. 子--初始化 
  10. 子--建構子 

現在，結果已經不言自明了。大家可能會注意到一點，那就是，並不是父類完全初始化完畢後才進行子類的初始化，實際上子類的靜態變數和靜態初始化的初始化是在父類的變數、初始化和建構子初始化之前就完成了。那麼對於靜態變數和靜態初始化之間、變數和初始化之間的先後順序又是怎樣呢？是否靜態變數總是先於靜態初始化，變數總是先於初始化就被初始化了呢？實際上這取決於它們在類中出現的先後順序。



我們以靜態變數和靜態初始化為例來進行說明。 同樣，我們還是寫一個類來進行測試：
原始碼
  1. public class TestOrder { 
  2.    // 靜態變數 
  3.    public static TestA a = new TestA(); 
  4.  
  5.    // 靜態初始化 
  6.    static { 
  7.        System.out.println("靜態初始化"); 
  8.    } 
  9.  
  10.    // 靜態變數 
  11.    public static TestB b = new TestB(); 
  12.  
  13.    public static void main(String[] args) { 
  14.        new TestOrder(); 
  15.    } 
  16. } 
  17.  
  18. class TestA { 
  19.    public TestA() { 
  20.        System.out.println("TestA"); 
  21.    } 
  22. } 
  23.  
  24. class TestB { 
  25.    public TestB() { 
  26.        System.out.println("TestB"); 
  27.    } 
  28. } 

運行上面的程式，會得到如下的結果：
  1. TestA 
  2. 靜態初始化 
  3. TestB 

大家可以隨意改變變數 a、變數 b 以及靜態初始化的前後位置，就會發現輸出結果隨著它們在類中出現的前後順序而改變，這就說明靜態變數和靜態初始化是依照他們在類中的定義順序進行初始化的。同樣，變數和初始化也遵循這個規律。了解了繼承情況下類的初始化順序之後，如何判斷最終輸出結果就迎刃而解了。



測試函數：
原始碼
  1. public class TestStaticCon { 
  2.    public static int a = 0; 
  3.  
  4.    static { 
  5.        a = 10; 
  6.        System.out.println("靜態初始化 a = " + a); 
  7.    } 
  8.  
  9.    { 
  10.        a = 8; 
  11.        System.out.println("初始化 a = " + a); 
  12.    } 
  13.  
  14.    public TestStaticCon() { 
  15.        this(a); 
  16.        System.out.println("無參數建構子 a = " + a); 
  17.    } 
  18.    public TestStaticCon(int n) { 
  19.        System.out.println("參數建構子 n = " + n); 
  20.        System.out.println("參數建構子 a = " + a); 
  21.    } 
  22.  
  23.  
  24.    public static void main(String[] args) { 
  25.        new TestStaticCon(); 
  26.    } 
  27. } 

運行結果：
  1. 靜態初始化 a = 10 
  2. 初始化 a = 8 
  3. 參數建構子 n = 10 
  4. 參數建構子 a = 8 
  5. 無參數建構子 a = 8 


結論：
靜態初始化是在類加載時自動執行的，非靜態初始化是在創建對像時自動執行的程式，不創建對像不執行該類的非靜態初始化。且執行順序為
靜態初始化 -> 非靜態初始化 -> 建構子


擴展( 靜態初始化 與 靜態方法 )：
一般情況下，如果有些程式必須在項目啟動的時候就執行的時候，需要使用靜態初始化，這種程式是主動執行的。
需要在項目啟動的時候就初始化，在不創建對像的情況下，其他程序來調用的時候，需要使用靜態方法，這種程式是被動執行的。
兩者的區別就是:靜態初始化是自動執行的。靜態方法是被調用的時候才執行的。


作用：
靜態初始化可用來初始化一些項目最常用的變數或類別靜態方法可用作不創建物件也可能需要執行的程式。



阿裡筆試題：
原始碼
  1. public class Test1 { 
  2.  
  3.    public static int k = 0; 
  4.    public static Test1 t1 = new Test1("obj t1"); 
  5.    public static Test1 t2 = new Test1("obj t2"); 
  6.    public static int i = print("var I"); 
  7.    public static int n = 99; 
  8.    public int j = print("var J"); 
  9.  
  10.    static{ 
  11.        print("static"); 
  12.    } 
  13.  
  14.    { 
  15.        print("init"); 
  16.    } 
  17.  
  18.    public Test1(String str){ 
  19.        print(str); 
  20.        ++i; 
  21.        ++n; 
  22.    } 
  23.  
  24.    public static int print(String str){ 
  25.        k++; 
  26.        System.out.printf("%-3s: %-8s i=%-4d n=%d", k, str, i, n); 
  27.        ++n; 
  28.        return ++i; 
  29.    } 
  30.  
  31.    public static void main(String[] args) { 
  32.        new Test1("main"); 
  33.    } 
  34. } 

運行結果：
  1. 1  : var J    i=0    n=0 
  2. 2  : init     i=1    n=1 
  3. 3  : obj t1   i=2    n=2 
  4. 4  : var J    i=4    n=4 
  5. 5  : init     i=5    n=5 
  6. 6  : obj t2   i=6    n=6 
  7. 7  : var I    i=8    n=8 
  8. 8  : static   i=9    n=99 
  9. 9  : var J    i=10   n=100 
  10. 10 : init     i=11   n=101 
  11. 11 : main     i=12   n=102 
分類： ,
相關文章 ：

0 回應:

張貼留言

訂閱： 張貼留言 (Atom)