類加載與實例化

時間 2020-02-20

標籤加載實例简体版

原文原文鏈接

類加載與實例化

基本步驟

類裝載分爲如下 5 個步驟：java

加載：根據查找路徑找到相應的 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了本類對象），則會暫停類加載過程先執行實例化過程，執行完畢再回到類加載過程安全

實例化過程

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

類的主動與被動使用

主動使用場景
- 最爲經常使用的 new 一個類的實例對象
- 直接調用類的靜態方法
- 操做該類或接口中聲明的非編譯期常量靜態字段
- 反射調用一個類的方法
- 初始化一個類的子類的時候，父類也至關於被程序主動調用了（若是調用子類的靜態變量是從父類繼承過並無複寫的，那麼也就至關於只用到了父類的東東，和子類無關，因此這個時候子類不須要進行類初始化）
- 直接運行一個main函數入口的類

全部的 JVM 實現，在首次主動使用某類的時候纔會加載該類。性能

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

編譯期常量

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

String 值爲 null 時，也會寫到類常量池中使用 new String("xx") 建立字符串時，獲得的字符串不是類常量池中的code
對於經過 new 產生一個字符串（假設爲」china」）時，會先去常量池中查找是否已經有了」china」對象，若是沒有則在常量池中建立一個此字符串對象，而後堆中再建立一個常量池中此」china」對象的拷貝對象。對象

變量初始化

普通成員變量在聲明時、代碼塊、構造方法中能夠被初始化
靜態變量在聲明時、靜態塊中能夠被初始化
成員變量有默認的初始值

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

局部變量聲明之後，java 虛擬機不會自動的初始化爲默認值

所以對於局部變量，必須先通過顯示的初始化，才能使用。若是編譯器確認一個局部變量在使用以前可能沒有被初始化，編譯器將報錯繼承

類加載器

功能

負責加載字節碼文件，class 文件在文件開頭有特定的文件標示，而且 ClassLoader 負責 class 文件的加載等，至於它是否能夠運行，則由 Execution Engine 決定
主要功能
- 定位和導入二進制 class 文件
- 驗證導入類的正確性
- 爲類分配初始化內存
- 幫助解析符號引用

委派模式

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

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

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

在 java 中任意一個類都是由這個類自己和加載這個類的類加載器來肯定這個類在JVM中的惟一性
優勢

使得類有了層次的劃分。就拿 java.lang.Object 來講，加載它通過一層層委託最終都由 Bootstrap ClassLoader 去找 jre\lib 中 rt.jar 裏面的 java.lang.Object 並加載到 JVM 中。若是有不法分子本身構造了一個 java.lang.Object，裏面嵌了很差的代碼，按照雙親委派模型來實現的話，最終加載到 JVM 中的只會是 rt.jar 裏面的東西，也就是說這些核心的基礎類代碼獲得了保護