探究java初始化的過程

   最近又在翻《thinking in java》，這本書，怎麼說呢，以前學java的時候，老師就沒有把它作為教材，但是我偏偏只買了這本書，一直收穫很大。好了，言歸正傳，結合自己的偶然遇到的一個在建構函式中調多態方法引起的思考，講述一下java的初始化到底是怎樣的一個過程。

   所謂初始化，當然也就指的是變數。變數可以是內建的變數或者我們建立的類的對象。

   有人說，本來初始化本來就是一件很簡單的事情，的確，但是java作為一門物件導向語言，由於具有繼承、多態，靜態、動態綁定等多種特性，所以其初始化的情景可謂是五花八門。現在就一步一步的分析其初始化過程。下面就是幾個小原則。優先順序依次遞減。

   1 靜態塊優先                                                                                                                                                                              

  程式首先會執行靜態塊的內容，這也就有了不寫main方法就跑hello world的小故事，相信說到這裡，大家就有了思路。我們都知道靜態類型是和類綁定的而不是和具體執行個體對象綁定。也就是說，引用一個靜態變數的方式往往是MyClass.xxx.這個特點決定了其在編譯的階段就已經分配好了固定的空間。  

  2 父類優先                                                                                                                                                                                  

   由於繼承的特性，當匯出類（子類）的對象被建立的時候，程式將向上追溯到最初的父類，執行其初始化的操作。然後一次向下調用子類的建構函式。按照這個思路，那麼每一個執行個體第一個要初始化的必定是Object類了。

 3 成員變數優先                                                                                                                                                                             

    一定要注意，成員變數按照其聲明的順序會被初始化，並且立刻被初始化為二進位的0,這個動作發生在所有事件之前，也就是編譯器會立刻將分配給對象的空間初始化。一會的小例子將證明這一點。

 最後就是調用類的構造方法了。

  下面有一個不錯的例子，為了示範成員變數最早被初始化為0了，我們將在父類的建構函式中調用子類的方法（利用了多態）。

   

 1 package fruit;
 2 
 3 import vege.Inner;
 4 
 5 
 6 /**
 7  * @author Octobershiner
 8  */
 9 public class Fruit {
10     //static block
11     static {
12         System.out.println("In Fruit static");
13     }
14     
15     private Inner i = new Inner(); //a private member
16     public Fruit(){
17         System.out.println("Before Fruit Constructor");
18         show();  //由於多態的特性，此處子類Apple覆寫的方法會被調用
19         System.out.println("After Fruit Constructor");
20     }
21     public void show(){
22         System.out.println("show:Fruit.");
23     }
24     
25     public static void main(String[] args) {
26         // TODO code application logic here
27         new Apple(3);
28     }
29        
30 }

   現在父類中須要初始化的有

•    靜態塊
•    一個Inner類私人成員
•    建構函式

  現在我們看子類的代碼  

 1 package fruit;
 2 
 3 public class Apple extends Fruit{
 4    //靜態塊
 5     static{
 6         System.out.println("In Apple static");
 7     }
 8     private int weight = 1; //初始化為1 注意區別這裡和 初始化為0
 9     
10     public Apple(int para_weight){
11         System.out.println("Before Apple Constructer: weight = "+weight);
12         weight = para_weight;
13         System.out.println("Apple Constructor: weight="+weight);
14     }
15     
16     @Override
17     public void show(){
18         System.out.println("show apple: weight =" + weight);
19     }
20     
21 }

   子類須要初始化的有

• 靜態塊
• 私人成員weight
• 建構函式

   那麼當我們啟動並執行時候會有怎樣的結果呢？猜想。。。。。

   下面就是執行的結果：

   

    Look! 首先執行父類的靜態塊，之後是子類的靜態塊，這兩個應該沒有什麼問題。接下來就是對父類成員變數的初始化了。首先是父類的私人成員Inner對象，列印了一條“ Inner Constructor”。

  接下來就是父類的建構函式，可見由於java的多態性，Fruit的構造方法調用了其子類Apple的show方法，並且我們可以清晰的看到，此刻Apple類中weight變數的值是0！說明，類的成員變數無論是否賦值，在各種初始化之前早已被設定為二進位0了。

  於是乎我想起了很多關於java的書都在說。。“如果類的私人變數沒有賦值，就會被設定為0”。。這句話顯然把時間弄混了。。。應該是編譯器早已初始化了私人變數，均為0，之後才會執行到指派陳述式。

  父類的建構函式結束之後，再次回到子類，初始化私人變數（也就是我們常說的指派陳述式，因為初始為0的工作早做完了）。所以我們才會看到“Before Apple Constructor weight = 1”,執行完建構函式後，我們就看到了weight終於變成了我們建立對象是傳進的3了，呼，初始化結束。

  總結                                                                                                                                                                                      

  那麼總結一下就是這樣的：

1. 編譯器初始化所有的已指派的空間為二進位0  （這是我們的私人變數都會為0，剛才的例子）
2. 執行父類靜態代碼 執行子類靜態代碼
3. 初始化父類成員變數（我們常說的指派陳述式）
4. 初始化父類建構函式
5. 初始化子類成員變數
6. 初始化子類建構函式

 

 

本文程式完整代碼 https://github.com/octobershiner/Java-Taste/tree/master/Fruit

請支援 Java Taste ：https://github.com/octobershiner/Java-Taste