類從被載入到JVM中開始，到解除安裝為止，整個生命週期包括：載入、驗證、準備、解析、初始化、使用和解除安裝七個階段。

其中類載入過程包括載入、驗證、準備、解析和初始化五個階段。

 

類載入器的任務就是根據一個類的全限定名來讀取此類的二進位制位元組流到JVM中，然後轉換為一個與目標類對應的java.lang.Class物件例項。
BootstrapClassLoader、ExtClassLoader和AppClassLoader
defineClass方法將位元組碼的byte陣列轉換為一個類的class物件例項，如果希望在類被記載到JVM時就被連結，那麼可以呼叫resolveClass方法。

 

自定義類載入器需要繼承抽象類ClassLoader，實現findClass方法，該方法會在loadClass呼叫的時候被呼叫，findClass預設會丟擲異常。

findClass方法表示根據類名查詢類物件
loadClass方法表示根據類名進行雙親委託模型進行類載入並返回類物件
defineClass方法表示跟根據類的位元組碼轉換為類物件

 

雙親委託模型，約定類載入器的載入機制

 

當一個類載入器接收到一個類載入的任務時，不會立即展開載入，而是將載入任務委託給它的父類載入器去執行，每一層的類都採用相同的方式，直至委託給最頂層的啟動類載入器為止。如果父類載入器無法載入委託給它的類，便將類的載入任務退回給下一級類載入器去執行載入。

雙親委託模型的工作過程是：如果一個類載入器收到了類載入的請求，它首先不會自己去嘗試載入這個類，而是把這個請求委託給父類載入器去完成，每一個層次的類載入器都是如此，因此所有的載入請求最終都應該傳送到頂層的啟動類載入器中，只有當父類載入器反饋自己無法完成這個載入請求（它的搜尋範圍中沒有找到所需要載入的類）時，子載入器才會嘗試自己去載入。
使用雙親委託機制的好處是：能夠有效確保一個類的全域性唯一性，當程式中出現多個限定名相同的類時，類載入器在執行載入時，始終只會載入其中的某一個類。

使用雙親委託模型來組織類載入器之間的關係，有一個顯而易見的好處就是Java類隨著它的類載入器一起具備了一種帶有優先順序的層次關係。例如類java.lang.Object，它存放在rt.jar之中，無論哪一個類載入器要載入這個類，最終都是委託給處於模型最頂端的啟動類載入器進行載入，因此Object類在程式的各種載入器環境中都是同一個類。相反，如果沒有使用雙親委託模型，由各個類載入器自行去載入的話，如果使用者自己編寫了一個稱為java.lang.Object的類，並放在程式的ClassPath中，那系統中將會出現多個不同的Object類，Java型別體系中最基礎的行為也就無法保證，應用程式也將會變得一片混亂。如果自己去編寫一個與rt.jar類庫中已有類重名的Java類，將會發現可以正常編譯，但永遠無法被載入執行。


雙親委託模型對於保證Java程式的穩定運作很重要，但它的實現卻非常簡單，實現雙親委託的程式碼都集中在java.lang.ClassLoader的loadClass()方法中，邏輯清晰易懂：先檢查是否已經被載入過，若沒有載入則呼叫父類載入器的loadClass()方法，若父載入器為空則預設使用啟動類載入器作為父載入器。如果父類載入器載入失敗，丟擲ClassNotFoundException異常後，再呼叫自己的findClass方法進行載入。

 

 

 

 

1、載入
簡單的說，類載入階段就是由類載入器負責根據一個類的全限定名來讀取此類的二進位制位元組流到JVM內部，並存儲在執行時記憶體區的方法區，然後將其轉換為一個與目標型別對應的java.lang.Class物件例項（Java虛擬機器規範並沒有明確要求一定要儲存在堆區中，只是hotspot選擇將Class對戲那個儲存在方法區中），這個Class物件在日後就會作為方法區中該類的各種資料的訪問入口。
2、連結
連結階段要做的是將載入到JVM中的二進位制位元組流的類資料資訊合併到JVM的執行時狀態中，經由驗證、準備和解析三個階段。
1）、驗證
驗證類資料資訊是否符合JVM規範，是否是一個有效的位元組碼檔案，驗證內容涵蓋了類資料資訊的格式驗證、語義分析、操作驗證等。
格式驗證：驗證是否符合class檔案規範
語義驗證：檢查一個被標記為final的型別是否包含子類；檢查一個類中的final方法視訊被子類進行重寫；確保父類和子類之間沒有不相容的一些方法宣告（比如方法簽名相同，但方法的返回值不同）
操作驗證：在運算元棧中的資料必須進行正確的操作，對常量池中的各種符號引用執行驗證（通常在解析階段執行，檢查是否通過富豪引用中描述的全限定名定位到指定型別上，以及類成員資訊的訪問修飾符是否允許訪問等）

 

 

2）、準備
為類中的所有靜態變數分配記憶體空間，併為其設定一個初始值（由於還沒有產生物件，例項變數不在此操作範圍內）
被final修飾的靜態變數，會直接賦予原值；類欄位的欄位屬性表中存在ConstantValue屬性，則在準備階段，其值就是ConstantValue的值
3）、解析
將常量池中的符號引用轉為直接引用（得到類或者欄位、方法在記憶體中的指標或者偏移量，以便直接呼叫該方法），這個可以在初始化之後再執行。
可以認為是一些靜態繫結的會被解析，動態繫結則只會在執行是進行解析；靜態繫結包括一些final方法(不可以重寫),static方法(只會屬於當前類)，構造器(不會被重寫)
3、初始化
將一個類中所有被static關鍵字標識的程式碼統一執行一遍，如果執行的是靜態變數，那麼就會使用使用者指定的值覆蓋之前在準備階段設定的初始值；如果執行的是static程式碼塊，那麼在初始化階段，JVM就會執行static程式碼塊中定義的所有操作。
所有類變數初始化語句和靜態程式碼塊都會在編譯時被前端編譯器放在收集器裡頭，存放到一個特殊的方法中，這個方法就是<clinit>方法，即類/介面初始化方法。該方法的作用就是初始化一箇中的變數，使用使用者指定的值覆蓋之前在準備階段裡設定的初始值。任何invoke之類的位元組碼都無法呼叫<clinit>方法，因為該方法只能在類載入的過程中由JVM呼叫。
如果父類還沒有被初始化，那麼優先對父類初始化，但在<clinit>方法內部不會顯示呼叫父類的<clinit>方法，由JVM負責保證一個類的<clinit>方法執行之前，它的父類<clinit>方法已經被執行。
JVM必須確保一個類在初始化的過程中，如果是多執行緒需要同時初始化它，僅僅只能允許其中一個執行緒對其執行初始化操作，其餘執行緒必須等待，只有在活動執行緒執行完對類的初始化操作之後，才會通知正在等待的其他執行緒。

 

 

 

下面是關於static

一、static代表著什麼

     在Java中並不存在全域性變數的概念，但是我們可以通過static來實現一個“偽全域性”的概念，在Java中static表示“全域性”或者“靜態”的意思，用來修飾成員變數和成員方法，當然也可以修飾程式碼塊。

     Java把記憶體分為棧記憶體和堆記憶體，其中棧記憶體用來存放一些基本型別的變數、陣列和物件的引用，堆記憶體主要存放一些物件。在JVM載入一個類的時候，若該類存在static修飾的成員變數和成員方法，則會為這些成員變數和成員方法在固定的位置開闢一個固定大小的記憶體區域（只要這個類被載入，Java虛擬機器就能根據類名在執行時資料區的方法區內定找到他們），有了這些“固定”的特性，那麼JVM就可以非常方便地訪問他們。同時如果靜態的成員變數和成員方法不出作用域的話，它們的控制代碼都會保持不變。同時static所蘊含“靜態”的概念表示著它是不可恢復的，即在那個地方，你修改了，他是不會變回原樣的，你清理了，他就不會回來了。

      同時被static修飾的成員變數和成員方法是獨立於該類的，它不依賴於某個特定的例項變數，也就是說它被該類的所有例項共享。所有例項的引用都指向同一個地方，任何一個例項對其的修改都會導致其他例項的變化。

public class User {
    private static int userNumber  = 0 ;
    
    public User(){
        userNumber ++;
    }
    
    public static void main(String[] args) {
        User user1 = new User();
        User user2 = new User();
        
        System.out.println("user1 userNumber：" + User.userNumber);
        System.out.println("user2 userNumber：" + User.userNumber);
    }
}    
------------
Output:
user1 userNumber：2
user2 userNumber：2

二、怎麼使用static

static可以用於修飾成員變數和成員方法，我們將其稱之為靜態變數和靜態方法，直接通過類名來進行訪問。

      ClassName.propertyName

      ClassName.methodName(……)

static修飾的程式碼塊表示靜態程式碼塊，當JVM裝載類的時候，就會執行這塊程式碼，其用處非常大。

1、static變數

      static修飾的變數我們稱之為靜態變數，沒有用static修飾的變數稱之為例項變數，他們兩者的區別是：

      靜態變數是隨著類載入時被完成初始化的，它在記憶體中僅有一個，且JVM也只會為它分配一次記憶體，同時類所有的例項都共享靜態變數，可以直接通過類名來訪問它。但是例項變數則不同，它是伴隨著例項的，每建立一個例項就會產生一個例項變數，它與該例項同生共死。

      所以我們一般在這兩種情況下使用靜態變數：物件之間共享資料、訪問方便。

public class TestStatic {
    
    public static int count = 0;
    
    public static void main(String[] args){
        TestStatic test1=new TestStatic();
        System.out.println(test1.count);
        TestStatic test2=new TestStatic();
        test2.count++;
        System.out.println(test1.count+" "+test2.count+" "+TestStatic.count);
    }
}

輸出結果：

0
1 1 1

可見，static變數並不是所在類的某個具體物件所有，而是該類的所有物件所共有的，靜態變數既能被物件呼叫，也能直接拿類來呼叫。

 2、static方法

     static方法一般稱作靜態方法，由於靜態方法不依賴於任何物件就可以進行訪問，因此對於靜態方法來說，是沒有this的，因為它不依附於任何物件，既然都沒有物件，就談不上this了。並且由於這個特性，在靜態方法中不能訪問類的非靜態成員變數和非靜態成員方法，因為非靜態成員方法/變數都是必須依賴具體的物件才能夠被呼叫。
　  但是要注意的是，雖然在靜態方法中不能訪問非靜態成員方法和非靜態成員變數，但是在非靜態成員方法中是可以訪問靜態成員方法/變數的。
     因為static方法獨立於任何例項，因此static方法必須被實現，而不能是抽象的abstract。
 
總結一下，對於靜態方法需要注意以下幾點：
（1）它們僅能呼叫其他的static 方法。
（2）它們只能訪問static資料。
（3）它們不能以任何方式引用this 或super。

舉個簡單的例子：

　　在上面的程式碼中，由於print2方法是獨立於物件存在的，可以直接用過類名呼叫。假如說可以在靜態方法中訪問非靜態方法/變數的話，那麼如果在main方法中有下面一條語句：

　　MyObject.print2();

　　此時物件都沒有，str2根本就不存在，所以就會產生矛盾了。同樣對於方法也是一樣，由於你無法預知在print1方法中是否訪問了非靜態成員變數，所以也禁止在靜態成員方法中訪問非靜態成員方法。

　　而對於非靜態成員方法，它訪問靜態成員方法/變數顯然是毫無限制的。

　　因此，如果說想在不建立物件的情況下呼叫某個方法，就可以將這個方法設定為static。我們最常見的static方法就是main方法，至於為什麼main方法必須是static的，現在就很清楚了。因為程式在執行main方法的時候沒有建立任何物件，因此只有通過類名來訪問。

　　另外記住，即使沒有顯示地宣告為static，類的構造器實際上也是靜態方法。

3、static程式碼塊

     static關鍵字還有一個比較關鍵的作用就是 用來形成靜態程式碼塊以優化程式效能。static塊可以置於類中的任何地方，類中可以有多個static塊。在類初次被載入的時候，會按照static塊的順序來執行每個static塊，並且只會執行一次。

　　為什麼說static塊可以用來優化程式效能，是因為它的特性:只會在類載入的時候執行一次。下面看個例子:

class Person{ 
    private Date birthDate; 
      
    public Person(Date birthDate) { 
        this.birthDate = birthDate; 
    } 
      
    boolean isBornBoomer() { 
        Date startDate = Date.valueOf("1946"); 
        Date endDate = Date.valueOf("1964"); 
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; 
    } 
} 

     isBornBoomer是用來判斷這個人是否是1946-1964年出生的，而每次isBornBoomer被呼叫的時候，都會生成startDate和birthDate兩個物件，造成了空間浪費，如果改成這樣效率會更好：

class Person{ 
    private Date birthDate; 
    private static Date startDate,endDate; 
    static{ 
        startDate = Date.valueOf("1946"); 
        endDate = Date.valueOf("1964"); 
    } 
      
    public Person(Date birthDate) { 
        this.birthDate = birthDate; 
    } 
      
    boolean isBornBoomer() { 
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0; 
    } 
} 

因此，很多時候會將一些只需要進行一次的初始化操作都放在static程式碼塊中進行。

三、static關鍵字的誤區

1、static關鍵字會改變類中成員的訪問許可權嗎？

    有些初學的朋友會將java中的static與C/C++中的static關鍵字的功能混淆了。在這裡只需要記住一點：與C/C++中的static不同，Java中的static關鍵字不會影響到變數或者方法的作用域。在Java中能夠影響到訪問許可權的只有private、public、protected（包括包訪問許可權）這幾個關鍵字。看下面的例子就明白了：

提示錯誤"Person.age 不可視"，這說明static關鍵字並不會改變變數和方法的訪問許可權。

2、能通過this訪問靜態成員變數嗎？

雖然對於靜態方法來說沒有this，那麼在非靜態方法中能夠通過this訪問靜態成員變數嗎？先看下面的一個例子，這段程式碼輸出的結果是什麼？

public class Main {　　 
    static int value = 33;  
  
    public static void main(String[] args) throws Exception{ 
        new Main().printValue(); 
    } 
  
    private void printValue(){ 
        int value = 3; 
        System.out.println(this.value); 
    } 
} 

輸出結果：33

     這裡面主要考查對this和static的理解。this代表什麼？this代表當前物件，那麼通過new Main()來呼叫printValue的話，當前物件就是通過new Main()生成的物件。而static變數是被物件所享有的，因此在printValue中的this.value的值毫無疑問是33。在printValue方法內部的value是區域性變數，根本不可能與this關聯，所以輸出結果是33。在這裡永遠要記住一點：靜態成員變數雖然獨立於物件，但是不代表不可以通過物件去訪問，所有的靜態方法和靜態變數都可以通過物件訪問（只要訪問許可權足夠）。

3、static能作用於區域性變數麼？

　　在C/C++中static是可以作用域區域性變數的，但是在Java中切記：static是不允許用來修飾區域性變數。不要問為什麼，這是Java語法的規定。

4、static和final一塊用表示什麼？
      static final用來修飾成員變數和成員方法，可簡單理解為“全域性常量”！ 
      對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。 
      對於方法，表示不可覆蓋，並且可以通過類名直接訪問。

四、常見的筆試面試題

下面列舉一些面試筆試中經常遇到的關於static關鍵字的題目

1、下面這段程式碼的輸出結果是什麼？

public class Test extends Base{ 
  
    static{ 
        System.out.println("test static"); 
    } 
      
    public Test(){ 
        System.out.println("test constructor"); 
    } 
      
    public static void main(String[] args) { 
        new Test(); 
    } 
} 
  
class Base{ 
      
    static{ 
        System.out.println("base static"); 
    } 
      
    public Base(){ 
        System.out.println("base constructor"); 
    } 
} 

輸出結果：

base static
test static
base constructor
test constructor

     至於為什麼是這個結果，我們先不討論，先來想一下這段程式碼具體的執行過程，在執行開始，先要尋找到main方法，因為main方法是程式的入口，但是在執行main方法之前，必須先載入Test類，而在載入Test類的時候發現Test類繼承自Base類，因此會轉去先載入Base類，在載入Base類的時候，發現有static塊，便執行了static塊。在Base類載入完成之後，便繼續載入Test類，然後發現Test類中也有static塊，便執行static塊。在載入完所需的類之後，便開始執行main方法。在main方法中執行new Test()的時候會先呼叫父類的構造器，然後再呼叫自身的構造器。因此，便出現了上面的輸出結果。

2、這段程式碼的輸出結果是什麼？

public class Test { 
    Person person = new Person("Test"); 
    static{ 
        System.out.println("test static"); 
    } 
      
    public Test() { 
        System.out.println("test constructor"); 
    } 
      
    public static void main(String[] args) { 
        new MyClass(); 
    } 
} 
  
class Person{ 
    static{ 
        System.out.println("person static"); 
    } 
    public Person(String str) { 
        System.out.println("person "+str); 
    } 
} 
  
  
class MyClass extends Test { 
    Person person = new Person("MyClass"); 
    static{ 
        System.out.println("myclass static"); 
    } 
      
    public MyClass() { 
        System.out.println("myclass constructor"); 
    } 
} 

輸出結果：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

     類似地，我們還是來想一下這段程式碼的具體執行過程。首先載入Test類，因此會執行Test類中的static塊。接著執行new MyClass()，而MyClass類還沒有被載入，因此需要載入MyClass類。在載入MyClass類的時候，發現MyClass類繼承自Test類，但是由於Test類已經被載入了，所以只需要載入MyClass類，那麼就會執行MyClass類的中的static塊。在載入完之後，就通過構造器來生成物件。而在生成物件的時候，必須先初始化父類的成員變數，因此會執行Test中的Person person = new Person()，而Person類還沒有被載入過，因此會先載入Person類並執行Person類中的static塊，接著執行父類的構造器，完成了父類的初始化，然後就來初始化自身了，因此會接著執行MyClass中的Person person = new Person()，最後執行MyClass的構造器。

3、這段程式碼的輸出結果是什麼？

public class Test {
     
    static{
        System.out.println("test static 1");
    }
    public static void main(String[] args) {
         
    }
     
    static{
        System.out.println("test static 2");
    }
}

執行結果：

test static 1
test static 2

    雖然在main方法中沒有任何語句，但是還是會輸出，原因上面已經講述過了。另外，static塊可以出現類中的任何地方（只要不是方法內部，記住，任何方法內部都不行），並且執行是按照static塊的順序執行的。

4、靜態程式碼塊的初始化順序

class Parent {
    static String name = "hello";
    {
        System.out.println("parent block");
    }
    static {
        System.out.println("parent static block");
    }

    public Parent() {
        System.out.println("parent constructor");
    }
}

class Child extends Parent {
    static String childName = "hello";
    {
        System.out.println("child block");
    }
    static {
        System.out.println("child static block");
    }

    public Child() {
        System.out.println("child constructor");
    }
}

public class TestStatic {

    public static void main(String[] args) {
        new Child();// 語句(*)
    }
}

問題：當執行完語句(*)時，列印結果是什麼順序？為什麼？

輸出結果：

parent static block
child static block
parent block
parent constructor
child block
child constructor

分析:當執行new Child()時，它首先去看父類裡面有沒有靜態程式碼塊，如果有，它先去執行父類裡面靜態程式碼塊裡面的內容，當父類的靜態程式碼塊裡面的內容執行完畢之後，接著去執行子類(自己這個類)裡面的靜態程式碼塊，當子類的靜態程式碼塊執行完畢之後，它接著又去看父類有沒有非靜態程式碼塊，如果有就執行父類的非靜態程式碼塊，父類的非靜態程式碼塊執行完畢，接著執行父類的構造方法；父類的構造方法執行完畢之後，它接著去看子類有沒有非靜態程式碼塊，如果有就執行子類的非靜態程式碼塊。子類的非靜態程式碼塊執行完畢再去執行子類的構造方法，這個就是一個物件的初始化順序。

總結:
物件的初始化順序:首先執行父類靜態的內容，父類靜態的內容執行完畢後，接著去執行子類的靜態的內容，當子類的靜態內容執行完畢之後，再去看父類有沒有非靜態程式碼塊，如果有就執行父類的非靜態程式碼塊，父類的非靜態程式碼塊執行完畢，接著執行父類的構造方法；父類的構造方法執行完畢之後，它接著去看子類有沒有非靜態程式碼塊，如果有就執行子類的非靜態程式碼塊。子類的非靜態程式碼塊執行完畢再去執行子類的構造方法。總之一句話，靜態程式碼塊內容先執行，接著執行父類非靜態程式碼塊和構造方法，然後執行子類非靜態程式碼塊和構造方法。

注意:子類的構造方法，不管這個構造方法帶不帶引數，預設的它都會先去尋找父類的不帶引數的構造方法。如果父類沒有不帶引數的構造方法，那麼子類必須用supper關鍵子來呼叫父類帶引數的構造方法，否則編譯不能通過。

參考資料：https://www.cnblogs.com/xiaoxian1369/p/5498817.html   

https://www.cnblogs.com/xiaoxi/p/6401481.html