類從被加載到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