類加載、對象實例化知識點一網打盡

時間 2021-01-04

標籤 java 面試多線程框架函數學習 .net 線程 code htm 欄目 Java 简体版

原文原文鏈接

前言

以前說了類加載的過程，可是有的讀者表示仍是有些知識點沒弄清楚，相關面試題也不能思考出結果，因此今天就來總結下類加載、對象實例化方面的知識點/面試題，幫助你們加深印象。java

全是乾貨，一網打盡類的基礎知識！先看看下面的問題都能回答上來嗎？面試

描述new一個對象的過程，並結合例子說明。
類初始化的觸發時機。
多線程進行類的初始化會出問題嗎？
類的實例化觸發時機。
<clinit>()方法和<init>()方法區別。
在類都沒有初始化完畢以前，能直接進行實例化相應的對象嗎?
類的初始化過程與類的實例化過程的異同？
一個實例變量在對象初始化的過程當中會被賦值幾回？

描述new一個對象的過程

先上圖，再描述：多線程

Java中對象的建立過程包括類初始化和類實例化兩個階段。
而new就是建立對象的一種方式，一種時機。框架

當執行到new的字節碼指令的時候，會先判斷這個類是否已經初始化，若是沒有初始化就要進行類的初始化，也就是執行類構造器<clinit>()方法。
若是已經初始化了，就直接進行類對象的實例化。函數

類的初始化，是類的生命週期中的一個階段，會爲類中各個類成員賦初始值。
類的實例化，是指建立一個類的實例的過程。

可是在類的初始化以前，JVM會保證類的裝載，連接（驗證、準備、解析）四個階段都已經完成，也就是上面的第一張圖。學習

裝載是指 Java 虛擬機查找.class文件並生成字節流，而後根據字節流建立java.lang.Class對象的過程。
連接是指驗證建立的類，並將其解析到JVM中使之可以被 JVM 執行。

那到底類加載的時機是何時呢？JVM 並無規範什麼時候具體執行，不一樣虛擬機的實現會有不一樣，常見有如下兩種狀況：.net

隱式裝載：在程序運行過程當中，當碰到經過 new 等方式生成對象時，系統會隱式調用 ClassLoader 去裝載對應的 class 到內存中；
顯示裝載：在編寫源代碼時，主動調用 Class.forName() 等方法也會進行 class 裝載操做，這種方式一般稱爲顯示裝載。

因此到這裏，大的流程框架就搞清楚了：線程

當JVM碰到new字節碼的時候，會先判斷類是否已經初始化，若是沒有初始化（有可能類尚未加載，若是是隱式裝載，此時應該尚未類加載，就會先進行裝載、驗證、準備、解析四個階段），而後進行類初始化。code
若是已經初始化過了，就直接開始類對象的實例化工做，這時候會調用類對象的<init>方法。htm

結合例子說明

而後說說具體的邏輯，結合一段類代碼：

public class Run {
    public static void main(String[] args) {
        new Student();
    }
}


public class Person{
    public static int value1 = 100;
    public static final int value2 = 200;

    public int value4 = 400;

    static{
        value1 = 101;
        System.out.println("1");
    }

    {
        value1 = 102;
        System.out.println("3");
    }

    public Person(){
        value1 = 103;
        System.out.println("4");
    }
}

public class Student extends Person{
    public static int value3 = 300;

    public int value5 = 500;

    static{
        value3 = 301;
        System.out.println("2");
    }

    {
        value3 = 302;
        System.out.println("5");
    }

    public Student(){
        value3 = 303;
        System.out.println("6");
    }
}

首先是類裝載，連接（驗證、準備、解析）。
當執行類準備過程當中，會對類中的靜態變量分配內存，並設置爲初始值也就是「0值」。好比上述代碼中的value1，value3，會爲他們分配內存，並將其設置爲0。可是注意，用final修飾靜態常量value2，會在這一步就設置好初始值102。
初始化階段，會執行類構造器<clinit>方法，其主要工做就是初始化類中靜態的（變量，代碼塊）。可是在當前類的<clinit>方法執行以前，會保證其父類的<clinit>方法已經執行完畢，因此一開始會執行最上面的父類Object的<clinit>方法，這個例子中會先初始化父類Person，再初始化子類Student。
初始化中，靜態變量和靜態代碼塊順序是由語句在源文件中出現的順序所決定的，也就是誰寫在前面就先執行誰。因此這裏先執行父類中的value1=100，value1 = 101，而後執行子類中的value3 = 300，value3 = 301。
接着就是建立對象的過程，也就是類的實例化，當對象被類建立時，虛擬機會分配內存來存放對象本身的實例變量和父類繼承過來的實例變量，同時會爲這些事例變量賦予默認值（0值）。
分配完內存後，會初始化父類的普通成員變量（value4 = 400），和執行父類的普通代碼塊（value1=102），順序由代碼順序決定。
執行父類的構造函數（value1 = 103）。
父類實例化完了，就實例化子類，初始化子類的普通成員變量（value5 = 500），執行子類的普通代碼塊（value3 = 302），順序由代碼順序決定。
執行子類的構造函數（value3 = 303）。

因此上述例子打印的結果是：

123456

總結一下執行流程就是：

父類靜態變量和靜態代碼塊；
子類靜態變量和靜態代碼塊；
父類普通成員變量和普通代碼塊；
父類的構造函數；
子類普通成員變量和普通代碼塊；
子類的構造函數。

最後，你們再結合流程圖好好梳理一下：

類初始化的觸發時機

在同一個類加載器下，一個類型只會被初始化一次，剛纔說到new對象是類初始化的一個判斷時機，其實一共有六種可以觸發類初始化的時機：

虛擬機啓動時，初始化包含 main 方法的主類；
遇到 new 等指令建立對象實例時，若是目標對象類沒有被初始化則進行初始化操做；
當遇到訪問靜態方法或者靜態字段的指令時，若是目標對象類沒有被初始化則進行初始化操做；
子類的初始化過程若是發現其父類尚未進行過初始化，則須要先觸發其父類的初始化；
使用反射 API 進行反射調用時，若是類沒有進行過初始化則須要先觸發其初始化；
第一次調用 java.lang.invoke.MethodHandle 實例時，須要初始化 MethodHandle 指向方法所在的類。

多線程進行類的初始化會出問題嗎

不會，<clinit>()方法是阻塞的，在多線程環境下，若是多個線程同時去初始化一個類，那麼只會有一個線程去執行這個類的<clinit>()，其餘線程都會被阻塞。

類的實例化觸發時機

使用new關鍵字建立對象
使用Class類的newInstance方法，Constructor類的newInstance方法(反射機制)
使用Clone方法建立對象
使用(反)序列化機制建立對象

`<clinit>()`方法和`<init>()`方法區別。

<clinit>()方法發生在類初始化階段，會執行類中的靜態類變量的初始化和靜態代碼塊中的邏輯，執行順序就是語句在源文件中出現的順序。
<init>()方法發生在類實例化階段，是默認的構造函數，會執行普通成員變量的初始化和普通代碼塊的邏輯，執行順序就是語句在源文件中出現的順序。

在類都沒有初始化完畢以前，能直接進行實例化相應的對象嗎?

剛纔都說了先初始化，再實例化，若是這個問題能夠的話那不是打臉了嗎？

沒錯，要打臉了哈哈。

確實是先進行類的初始化，再進行類的實例化，可是若是咱們在類的初始化階段就直接實例化對象呢？好比：

public class Run {
    public static void main(String[] args) {
        new Person2();
    }
}

public class Person2 {
    public static int value1 = 100;
    public static final int value2 = 200;

    public static Person2 p = new Person2();
    public int value4 = 400;

    static{
        value1 = 101;
        System.out.println("1");
    }

    {
        value1 = 102;
        System.out.println("2");
    }

    public Person2(){
        value1 = 103;
        System.out.println("3");
    }
}

嘿嘿，這時候該怎麼打印結果呢？

按照上面說過的邏輯，應該是先靜態變量和靜態代碼塊，而後普通成員變量和普通代碼塊，最後是構造函數。

可是由於靜態變量又執行了一次new Person2()，因此實例化過程被強行提早了，在初始化過程當中就進行了實例化。這段代碼的結果就變成了：

23123

因此，實例化不必定要在類初始化結束以後纔開始初始化，有可能在初始化過程當中就進行了實例化。

類的初始化過程與類的實例化過程的異同？

學了上面的內容，這個問題就很簡單了：

類的初始化，是指在類裝載，連接以後的一個階段，會執行<clinit>()方法，初始化靜態變量，執行靜態代碼塊等。只會執行一次。
類的實例化，是指在類徹底加載到內存中後建立對象的過程，會執行<init>()方法，初始化普通變量，調用普通代碼塊。能夠被調用屢次。

一個實例變量在對象初始化的過程當中最多能夠被賦值幾回？

那咱們就試試舉例出最多的狀況，其實也就是每一個要通過的地方都對實例變量進行一次賦值：

一、對象被建立時候，分配內存會把實例變量賦予默認值，這是確定會發生的。
二、實例變量自己初始化的時候，就給他賦值一次，也就是int value1=100。
三、初始化代碼塊的時候，也賦值一次。
四、構造函數中，在進行賦值一次。

一共四次，看代碼：

public class Person3 {
    public int value1 = 100;

    {
        value1 = 102;
        System.out.println("2");
    }

    public Person3(){
        value1 = 103;
        System.out.println("3");
    }
}