Java 類加載與實例化

基本步驟

類裝載分為以下 5 個步驟：

• 加載：根據查找路徑找到相應的 class 文件然后導入
• 檢查：檢查加載的 class 文件的正確性
• 准備：給類中的靜態變量分配內存空間
• 解析：虛擬機將常量池中的符號引用替換成直接引用的過程。符號引用理解為一個標示，而直接引用直接指向內存中的地址
• 初始化：對靜態變量和靜態代碼塊執行初始化工作

加載過程

public class ClassLoadTest {
    public static int k = 0;
    public static ClassLoadTest t1 = new ClassLoadTest("t1");
    public static ClassLoadTest t2 = new ClassLoadTest("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");
    {
        print("構造塊");
    }
    static {
        print("靜態塊");
    }
    public ClassLoadTest(String str) {
        System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n);
        ++n;
        ++i;
    }
    public static int print(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "   n=" + n);
        ++n;
        return ++i;
    }
    public static void main(String[] args) {
        new ClassLoadTest("ClassLoadTest");
    }
}

print

1:j   i=0   n=0
2:構造塊   i=1   n=1
3:t1    i=2  n=2
4:j   i=3   n=3
5:構造塊   i=4   n=4
6:t2    i=5  n=5
7:i   i=6   n=6
8:靜態塊   i=7   n=99
9:j   i=8   n=100
10:構造塊   i=9   n=101
11:ClassLoadTest    i=10  n=102  

示例分析

• 執行 main 時，先加載所在類，聲明靜態變量，並初始化靜態變量執行靜態代碼塊（按順序執行）
• 初始化到 t1 時，暫停類加載，先實例化，此時 k=0，而 i，n 都未初始化，系統默認值為 0
  初始化 j 時， k 自增為 1，i，n 為0，輸出 “1:j i=0 n=0”，n,i 自增為 1
  執行代碼塊，輸出 “2:構造塊 i=1 n=1”，n,i 自增為 2
  執行構造函數，輸出 “3:t1 i=2 n=2”，n,i 自增為 3
• 初始化到 t2 時，暫停類加載，先實例化，此時 k=3，i，n 都還未初始化，但已自增為 3
  初始化 j 時，k 自增為 4，i，n 未初始化為 3，輸出 “4:j i=3 n=3”，n,i 自增為 4
  執行代碼塊，輸出 “5:構造塊 i=4 n=4”，n,i 自增為 5
  執行構造函數，輸出 “6:t2 i=5 n=5”，n,i 自增為 6
• 初始化 i，輸出 “7:i i=6 n=6”，n,i 自增為 7，返回自增后的i賦值給 i
• 初始化 n，賦值 99
• 執行靜態塊，輸出 “8:靜態塊 i=7 n=99”，i 自增為 8，n 自增為 100

類加載過程

加載某類前先加載其父類
加載某類時，先聲明靜態成員變量，初始化為默認值，再初始化靜態成員變量執行靜態代碼塊
初始化靜態成員變量執行靜態代碼塊時，是按順序執行（初始化靜態成員變量的本質就是靜態代碼塊）

在某類加載過程中調用了本類實例化過程（如new了本類對象），則會暫停類加載過程先執行實例化過程，執行完畢再回到類加載過程

實例化過程

對某類實例化前，先對其父類進行實例化
實例化某類時，先聲明成員變量，初始化為默認值，再初始化成員變量執行代碼塊
初始化成員變量執行代碼塊時，是按順序執行

類的主動與被動使用

1. 主動使用場景
   • 最為常用的 new 一個類的實例對象
   • 直接調用類的靜態方法
   • 操作該類或接口中聲明的非編譯期常量靜態字段
   • 反射調用一個類的方法
   • 初始化一個類的子類的時候，父類也相當於被程序主動調用了（如果調用子類的靜態變量是從父類繼承過並沒有復寫的，那么也就相當於只用到了父類的東東，和子類無關，所以這個時候子類不需要進行類初始化）
   • 直接運行一個main函數入口的類

所有的 JVM 實現，在首次主動使用某類的時候才會加載該類。

2. 被動使用場景
   • 子類調用父類的靜態變量，子類不會被初始化。只有父類被初始化。對於靜態字段，只有直接定義這個字段的類才會被初始化
   • 通過數組定義來引用類，不會觸發類的初始化，如SubClass[] sca = new SubClass[10]
   • 訪問類的編譯期常量，不會初始化類

編譯期常量

1. 寫到類常量池中的類型是有限的：String 和幾個基本類型

   String 值為 null 時，也會寫到類常量池中
   使用 new String("xx") 創建字符串時，得到的字符串不是類常量池中的

2. 對於通過 new 產生一個字符串（假設為 ”china” ）時，會先去常量池中查找是否已經有了 ”china” 對象，
   如果沒有則在常量池中創建一個此字符串對象，然后堆中再創建一個常量池中此 ”china” 對象的拷貝對象。

變量初始化

1. 普通成員變量在聲明時、代碼塊、構造方法中可以被初始化
2. 靜態變量在聲明時、靜態塊中可以被初始化
3. 成員變量有默認的初始值

byte:0(8位)
short:0(16位)
int:0(32位)
long:0L(64位)
char:\u0000(16位)，代表NULL
float:0.0F(32位)
double:0.0(64位)
boolean: flase

4. 局部變量聲明以后，java 虛擬機不會自動的初始化為默認值

因此對於局部變量，必須先經過顯示的初始化，才能使用。如果編譯器確認一個局部變量在使用之前可能沒有被初始化，編譯器將報錯

類加載器

分類

graph TB B(Bootstrap ClassLoader)-->E(ExtensionClassLoder) E-->S(Application ClassLoader) S-->U(User-Defined ClassLoder)

1. 啟動類加載器，Bootstrap classLoader（jre\lib\rt.jar 包括 java.lang 等核心類庫）

   當運行 java 虛擬機時，這個類加載器被創建，它加載一些基本的 java API，包括 Object 這個類。需要注意的是，這個類加載器是用 C/C++ 實現的

2. 擴展類加載器，Extension class loader（jre\lib\ext\ *.jar 等）

   這個加載器加載出了基本API之外的一些拓展類，包括一些與安全性能相關的類

3. 應用程序類加載器，Application ClassLoader（classpath 指定內容）

   它加載應用程序中的類，也就是在 classpath 中配置的類

4. User-Defined ClassLoader

   開發人員通過拓展 ClassLoader 類定義的自定義加載器，加載程序員定義的一些類

功能

1. 負責加載字節碼文件，class 文件在文件開頭有特定的文件標示，並且 ClassLoader 負責 class 文件的加載等，至於它是否可以運行，則由 Execution Engine 決定

2. 主要功能

   • 定位和導入二進制 class 文件

   • 驗證導入類的正確性

   • 為類分配初始化內存

   • 幫助解析符號引用

委派模式

1. 自下而上檢測是否已經加載類

   當 JVM 加載一個類的時候，下層的加載器會將任務委托給上一層類加載器，上一層加載檢查它的命名空間中是否已經加載這個類，如果已經加載，直接使用這個類。如果沒有加載，繼續往上委托直到頂層

2. 由上而下嘗試加載類

   檢查完畢沒有加載該類，則按照相反的順序進行加載，如果 Bootstrap 加載器找不到這個類，則往下委托，直到找到類文件。對於某個特定的類加載器來說，一個 java類 只能被載入一次，也就是說在 java 虛擬機中，類的完整標識是（classLoader，package，className）

   在 java 中任意一個類都是由這個類本身和加載這個類的類加載器來確定這個類在JVM中的唯一性

3. 優點

   使得類有了層次的划分。就拿 java.lang.Object 來說，加載它經過一層層委托最終都由 Bootstrap ClassLoader 去找 jre\lib 中 rt.jar 里面的 java.lang.Object 並加載到 JVM 中。如果有不法分子自己構造了一個 java.lang.Object，里面嵌了不好的代碼，按照雙親委派模型來實現的話，最終加載到 JVM 中的只會是 rt.jar 里面的東西，也就是說這些核心的基礎類代碼得到了保護