Java系列筆記(1) - Java 類加載與初始化

目錄

1. 類加載器
2. 動態加載
3. 鏈接
4. 初始化
5. 示例

類加載器

在了解Java的機制之前，需要先了解類在JVM（Java虛擬機）中是如何加載的，這對后面理解java其它機制將有重要作用。

每個類編譯后產生一個Class對象，存儲在.class文件中，JVM使用類加載器（Class Loader）來加載類的字節碼文件（.class），類加載器實質上是一條類加載器鏈，一般的，我們只會用到一個原生的類加載器，它只加載Java API等可信類，通常只是在本地磁盤中加載，這些類一般就夠我們使用了。如果我們需要從遠程網絡或數據庫中下載.class字節碼文件，那就需要我們來掛載額外的類加載器。

一般來說，類加載器是按照樹形的層次結構組織的，每個加載器都有一個父類加載器。另外，每個類加載器都支持代理模式，即可以自己完成Java類的加載工作，也可以代理給其它類加載器。

類加載器的加載順序有兩種，一種是父類優先策略，一種是是自己優先策略，父類優先策略是比較一般的情況（如JDK采用的就是這種方式），在這種策略下，類在加載某個Java類之前，會嘗試代理給其父類加載器，只有當父類加載器找不到時，才嘗試自己去加載。自己優先的策略與父類優先相反，它會首先嘗試子經濟加載，找不到的時候才要父類加載器去加載，這種在web容器（如tomcat）中比較常見。

動態加載

不管使用什么樣的類加載器，類，都是在第一次被用到時，動態加載到JVM的。這句話有兩層含義：

1. Java程序在運行時並不一定被完整加載，只有當發現該類還沒有加載時，才去本地或遠程查找類的.class文件並驗證和加載；
2. 當程序創建了第一個對類的靜態成員的引用（如類的靜態變量、靜態方法、構造方法——構造方法也是靜態的）時，才會加載該類。Java的這個特性叫做：動態加載。

需要區分加載和初始化的區別，加載了一個類的.class文件，不以為着該Class對象被初始化，事實上，一個類的初始化包括3個步驟：

• 加載（Loading），由類加載器執行，查找字節碼，並創建一個Class對象（只是創建）；
• 鏈接（Linking），驗證字節碼，為靜態域分配存儲空間（只是分配，並不初始化該存儲空間），解析該類創建所需要的對其它類的應用；
• 初始化（Initialization），首先執行靜態初始化塊static{}，初始化靜態變量，執行靜態方法（如構造方法）。

鏈接

Java在加載了類之后，需要進行鏈接的步驟，鏈接簡單地說，就是將已經加載的java二進制代碼組合到JVM運行狀態中去。它包括3個步驟：

1. 驗證（Verification），驗證是保證二進制字節碼在結構上的正確性，具體來說，工作包括檢測類型正確性，接入屬性正確性（public、private），檢查final class 沒有被繼承，檢查靜態變量的正確性等。
2. 准備（Preparation），准備階段主要是創建靜態域，分配空間，給這些域設默認值，需要注意的是兩點：一個是在准備階段不會執行任何代碼，僅僅是設置默認值，二個是這些默認值是這樣分配的，原生類型全部設為0，如：float:0f,int 0, long 0L, boolean:0（布爾類型也是0），其它引用類型為null。
   
3. 解析（Resolution），解析的過程就是對類中的接口、類、方法、變量的符號引用進行解析並定位，解析成直接引用（符號引用就是編碼是用字符串表示某個變量、接口的位置，直接引用就是根據符號引用翻譯出來的地址），並保證這些類被正確的找到。解析的過程可能導致其它的類被加載。需要注意的是，根據不同的解析策略，這一步不一定是必須的，有些解析策略在解析時遞歸的把所有引用解析，這是early resolution，要求所有引用都必須存在；還有一種策略是late resolution，這也是Oracle 的JDK所采取的策略，即在類只是被引用了，還沒有被真正用到時，並不進行解析，只有當真正用到了，才去加載和解析這個類。
   

初始化

注 意：在《Java編程思想》中，說static{}子句是在類第一次加載時執行且執行一次（可能是筆誤或翻譯錯誤，因為此書的例子顯示static是在第 一次初始化時執行的），《Java深度歷險》中說 static{}是在第一次實例化時執行且執行一次，這兩種應該都是錯誤的，static{}是在第一次初始化時執行，且只執行一次；用下面的代碼可以判 定出來：

package myblog.classloader;

/**
 * @project MyBlog
 * @create 2013年6月18日 下午7:00:45
 * @version 1.0.0
 * @author 張廣
 */
public class Toy {
        private String name;

        public static final int price=10;
        
        static {
                System.out.println("Initializing");
        }

        Toy() {
                System.out.println("Building");
        }
        Toy(String name) {
                this.setName(name);
        }

        public static String playToy(String player) {
                String msg = buildMsg(player);
                System.out.println(msg);
                return msg;
        }
        private String buildMsg(String player) {
                String msg = player + " plays " + name;
                return msg;
        }
}
  // 對上面的類，執行下面的代碼：
  Class c = Class.forName("myblog.rtti.Toy");
  // c.newInstance();

可以看到，不實例化，只執行forName初始化時，仍然會執行static{}子句，但不執行構造方法，因此輸出的只有Initializing，沒有Building。

關於初始化，@阿春阿曉 在本文的評論中給出了很詳細的場景，感謝@阿春阿曉：

根據java虛擬機規范，所有java虛擬機實現必須在每個類或接口被java程序首次主動使用時才初始化。

主動使用有以下6種：
1) 創建類的實例
2) 訪問某個類或者接口的靜態變量，或者對該靜態變量賦值（如果訪問靜態編譯時常量(即編譯時可以確定值的常量)不會導致類的初始化）
3) 調用類的靜態方法
4) 反射（Class.forName(xxx.xxx.xxx)）
5) 初始化一個類的子類（相當於對父類的主動使用），不過直接通過子類引用父類元素，不會引起子類的初始化（參見示例6）
6) Java虛擬機被標明為啟動類的類（包含main方法的）

類與接口的初始化不同，如果一個類被初始化，則其父類或父接口也會被初始化，但如果一個接口初始化，則不會引起其父接口的初始化。

示例

1，通過上面的講解，將可以理解下面的程序（下面的程序部分來自於《Java編程思想》）：

class Toy {
        static {
                System.out.println("Initializing");// 靜態子句，只在類第一次被加載並初始化時執行一次，而且只執行一次
        }

        Toy() {
                System.out.println("Building");// 構造方法，在每次聲明新對象時加載
        }
}

對上面的程序段，第一次調用Class.forName("Toy")，將執行static子句；如果在之后執行new Toy()都只執行構造方法。

2，需要注意newInstance()方法

Class cc = Class.forName("Toy");//獲得類（注意，需要使用含包名的全限定名）
Toy toy=(Toy)cc.newInstance(); //相當於new一個對象，但Gum類必須有默認構造方法（無參）

3，用類字面常量 .class和Class.forName都可以創建對類的應用，但是不同點在於，用Gum.class創建Class對象的應用時，不會自動初始化該Class對象（static子句不會執行）

public class TestToy {
        public static void main(String[] args) {
                // try {
                // Class c = Class.forName("myblog.classloader.Toy");
                // } catch (ClassNotFoundException e) {
                // e.printStackTrace();
                // }
                Class c = Toy.class; // 不會輸出任何值
        }
}

使用Toy.class是在編譯期執行的，因此在編譯時必須已經有了Toy的.class文件，不然會編譯失敗，這與 Class.forName("myblog.classloader.Toy")不同，后者是運行時動態加載。

但是，如果該main方法是直接寫在Toy類中，那么調用Toy.class，會引起初始化，並輸出Initializing，原因並不是Toy.class引起的，而是該類中含有啟動方法main，該方法會導致Toy的初始化。

 4，編譯時常量。回到完整的類Toy，如果直接輸出：System.out.println(Toy.price)，會發現static子句和構造方法都沒有被執行，這是因為Toy中，常量price被static final限定，這樣的常量叫做編譯時常量，對於這種常量，不需要初始化就可以讀取。
編譯時常量必須滿足3個條件：static的，final的，常量。

下面幾種都不是編譯時常量，對它們的應用，都會引起類的初始化：

static int a;

final  int b;

static final  int c= ClassInitialization.rand.nextInt(100);

static final  int d;
static {
    d=5;
}

5，static塊的本質。注意下面的代碼：

class StaticBlock {
        static final int c = 3;

        static final int d;

        static int e = 5;
        static {
                d = 5;
                e = 10;
                System.out.println("Initializing");
        }

        StaticBlock() {
                System.out.println("Building");
        }
}

public class StaticBlockTest {
        public static void main(String[] args) {
                System.out.println(StaticBlock.c);
                System.out.println(StaticBlock.d);
                System.out.println(StaticBlock.e);
        }
}

這段代碼的輸出是什么呢？Initialing在c、d、e之前輸出，還是在之后？e輸出的是5還是10？

執行一下，結果為：

3
Initializing
5
10

答案是3最先輸出，Intializing隨后輸出，e輸出的是10，為什么呢？

原因是這樣的：輸出c時，由於c是編譯時常量，不會引起類初始化，因此直接輸出，輸出d時，d不是編譯時常量，所以會引起初始化操作，即static塊的執行，於是d被賦值為5，e被賦值為10，然后輸出Initializing，之后輸出d為5，e為10。

但e為什么是10呢？原來，JDK會自動為e的初始化創建一個static塊（參考：http://www.java3z.com/cwbwebhome/article/article8/81101.html?id=2497），所以上面的代碼等價於：

class StaticBlock {
        static final int d;

        static int e;
        
        static {
           e=5; 
        }

        static {
            d = 5;
            e = 10;
            System.out.println("Initializing");
        }

        StaticBlock() {
            System.out.println("Building");
        }
}    

可見，按順序執行，e先被初始化為5，再被初始化為10，於是輸出了10。

類似的，容易想到下面的代碼：

class StaticBlock {
        static {
                d = 5;
                e = 10;
                System.out.println("Initializing");
        }

        static final int d;

        static int e = 5;

        StaticBlock() {
                System.out.println("Building");
        }
}

在這段代碼中，對e的聲明被放到static塊后面，於是，e會先被初始化為10，再被初始化為5，所以這段代碼中e會輸出為5。

6，當訪問一個Java類或接口的靜態域時，只有真正聲明這個域的類或接口才會被初始化（《Java深度歷險》）

/**
 * 例子來源於《Java深度歷險》第二章
 * @author 張廣
 *
 */
class B {
        static int value = 100;
        static {
                System.out.println("Class B is initialized");// 輸出
        }
}

class A extends B {
        static {
                System.out.println("Class A is initialized"); // 不輸出
        }
}

public class SuperClassTest {
        public static void main(String[] args) {
                System.out.println(A.value);// 輸出100
        }
}

在該例子中，雖然通過A來引用了value，但value是在父類B中聲明的，所以只會初始化B，而不會引起A的初始化。

說明

筆者在開發過程中發現自己基礎太薄弱，讀書時除了系統學習了一下Java的基礎語法和用法、一點簡單的數據結構和設計模式之外，再無深入系統的學習，而工作中的學習也是東晃一槍西晃一槍，不夠扎實和系統。想到一個學習方法：學到的東西能夠系統的表達出來，才說明你學到手了；於是，筆者決定邊學邊寫，將學到的東西以博客的形式表達出來。

本文檔會因學習的深入或錯誤的訂正而持續更新。

《Java系列筆記》是本人對Java的應用和學習過程中的筆記，按知識點分章節，寫這一系列筆記的目的是學習，由於筆者是邊學編寫的，水平有限，文中必定有疏漏之處，歡迎斧正。

文中多有參考前輩的書籍和博客之處，原則上不會原文引用，而是加入自己的理解改造之，如果有引用，必會注明出處，如有疑問，請聯系：[e-mail]

更新記錄

2013年6月25日：發表；

2013年6月26日：加入@阿春阿曉的評論：引起初始化的6種場景；

2013年6月28日：加入鏈接和初始化的內容，加入示例6

本節參考資料

JAVA編程思想，第14章

Java深度歷險

Java中static塊的本質：http://www.java3z.com/cwbwebhome/article/article8/81101.html?id=2497

 java類的裝載(Loading)、鏈接(Linking)和初始化(Initialization)：http://blog.csdn.net/biaobiaoqi/article/details/6909141