類的加載的最終產品是位於內存中的Class對象
Class對象封裝了類在方法區內的數據結構，並且向java程序員提供了訪問方法區內的數據結構的接口

有兩種類型的類加載器

java虛擬機自帶的加載器
1.根類加載器（Bootstrap）
2.擴展類加載器（Extension）
3.系統（應用）類加載器（System）
用戶自定義的類加載器
1.java.lang.ClassLoader的子類
2.用戶可以定製類的加載方式
包括自定義類加載器在構造的時候在構造方法中傳入了一個父類加載

類的加載器並不需要等到某個類被“首次主動使用”時再加載它（個人理解加載不一定初始化，初始化一定加載）

jvm規範允許類加載器在預料某個類將要被使用時就預先加載他，如果在預先加載的過程中遇到了.class文件缺失或存在錯誤，類加載器必須在程序首次主動使用該類時才報告錯誤（LinkageError錯誤）
如果這個類一直沒有被程序主動使用,那麼類加載器就不會報告錯誤

類被加載後,就進入鏈接階段。鏈接就是將已經讀入到內存的類的二進制數據合併到虛擬機的運行時環境中去

類的初始化

類的初始化步驟

假如這個類還沒有被加載和連接，那就先進行加載和連接
假如類存在直接父類，並且這個父類還沒有被初始化，那就先初始化直接父類
假如類中存在初始化語句，那就依次執行這些初始化語句

類的初始化時機

主動使用（7種，重要）除了七種情形，其他使用java類的方式都被看做是被動使用，不會導致類的初始化

示例

public class Test5 {

    public static void main(String[] args) {
          //驗證初始化一個類時,並不會先初始化它所實現的接口
//        System.out.println(MyChild5.b);
        //驗證初始化一個接口時,並不會初始化它所實現的接口
        System.out.println(MyChild5_1.thread);
    }
}

interface MyParcnt5{

    public static Thread thread = new Thread(){
        {
            System.out.println("MyParcnt5 invoked");
        }
    };
    public static final int a = 5;
}

//interface MyChild5 extends MyParcnt5{
//
//    public static int b = new Random().nextInt(4);
//}
class MyChild5 implements MyParcnt5{
    //此時MyChild5 被加載並沒有被初始化  （加載不一定初始化，初始化一定加載）
    public static int b = 6;
}


interface MyParcnt5_1{
    public static Thread thread = new Thread(){
        {
            System.out.println("MyParcnt5_1 invoked");
        }
    };
}

interface MyChild5_1 extends MyParcnt5_1 {
    public static Thread thread = new Thread(){
        {
            System.out.println("MyChild5_1 invoked");
        }
    };
}

類加載器雙親委託機制詳解

他們之間存在的是包含關係不是繼承關係樹形結構

public abstract class ClassLoader {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    // The parent class loader for delegation
    // Note: VM hardcoded the offset of this field, thus all new fields
    // must be added *after* it.
    private final ClassLoader parent;

ClassLoader中有一個成員變量定義着雙親因爲除了根類加載器每個加載器都繼承於ClassLoder 所以每個ClassLoaderd都存在這對應的雙親所以他們之間存在的是包含關係不是繼承關係樹形結構

在雙親委託機制中,各個加載器按照父子關係形成了樹形結構,除了根類加載器之外,其餘的類加載器都有且只有一個父加載器

基本上項目當中字節寫的類加載都是由系統類加載器進行加載完成的

每個類都需要類加載器去加載，如果有父類,先讓父類去加載，如此向上追溯，直到根類加載器，然後根類加載器嘗試去加載，加載成功賊結束，加載失敗，又往下，一層層的嘗試去加載，最終如果都沒有加載成功則報錯

通過示例回顧之前學的知識點

public class Test7 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz = Class.forName("java.lang.String");
        System.out.println(clazz.getClassLoader());//獲取類加載器,如果是Bootstrap ClassLoader 根加載器加載可能會返回null

        Class<?> clazs = Class.forName("com.example.demo.com.jvm.C");
        System.out.println(clazs.getClassLoader());//sun.misc.Launcher$AppClassLoader@18b4aac2 基本上工程編寫的類都是由系統（應用）加載器AppClassLoader加載的
    }
}

class C {

}

打印結果

null
sun.misc.Launcher$AppClassLoader@18b4aac2

class FinalTest {
    public static final int x = 3;
//    public static final int x = new Random().nextInt(3);

    static {
        System.out.println("FinalTest static block");
    }
}

public class Test8 {

    public static void main(String[] args) {
        System.out.println(FinalTest.x);
    }
}


/*
    public static final int x = 3; 時 此時在編譯階段 常量x 會被放進Test8的常量池 直接拿來使用 		    FinalTest 並不會被初始化

    3
 */


/*
    public static final int x = new Random().nextInt(3);時 new Random().nextInt(3)生成隨機數實在運行時生成的 所以 Test8和FinalTest  有聯繫 此時FinalTest類會被加載

    FinalTest static block
    1

*/

class Parent {

    static int a = 3;

    static {
        System.out.println("Parent static block");
    }

}

class Child extends Parent {

    static int b = 4;

    static {
        System.out.println("Child static block");
    }

}

public class Test9 {

    static {
        System.out.println("Test9 static block");
    }

    public static void main(String[] args) {
        System.out.println(Child.b);
    }
}

/*
以此遞進 先加載test9 調用子類 先初始化父類 類的初始化7中之一
 Test9 static block
 Parent static block
 Child static block
 4
 */

class Parent1 {

    static int a = 3;

    static {
        System.out.println("Parent static block");
    }

}

class Child1 extends Parent1 {

    static int b = 4;

    static {
        System.out.println("Child static block");
    }

}

public class Test10 {
    static {
        System.out.println("Test10 static block");
    }

    public static void main(String[] args) {
        Parent1 parent1;

        System.out.println("===========");

        parent1 = new Parent1();

        System.out.println("===========");

        System.out.println(parent1.a);

        System.out.println("===========");

        System.out.println(Child1.b);
    }
}

/*
類只會首次加載纔會初始化
Test10 static block
===========
Parent static block
===========
3
===========
Child static block
4

 */

class Parent3 {
    static int a = 3;

    static {
        System.out.println("Parent3 static block");
    }

    static void doSomething() {
        System.out.println("do doSomething");
    }
}

class Child3 extends Parent3 {

    static {
        System.out.println("Child3 static block");
    }
}

public class Test11 {

    public static void main(String[] args) {
        System.out.println(Child3.a); //類名.父類靜態變量和靜態方法 表示對父類的主動使用 此時子類並不初始化
        System.out.println("---------------");
        Child3.doSomething();
    }
}


/*
類名.父類靜態變量和靜態方法 表示對父類的主動使用 此時子類並不初始化
Parent3 static block
3
---------------
do doSomething
 */

//調用ClassLoader類的loadClass方法加載一個類,並不是對類的主動使用,不會導致類的初始化

public class Test12 {

    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader loder = ClassLoader.getSystemClassLoader(); //獲取系統加載器

        Class<?> aClass = loder.loadClass("com.example.demo.com.jvm.CL");//加載對應類 除卻7種都是被動使用 不會初始化

        System.out.println(aClass);

        System.out.println("-----------------");

        Class<?> aClass1 = Class.forName("com.example.demo.com.jvm.CL");//7種之一
        System.out.println(aClass1);

    }
}

/*
只有反射初始化CL了 調用ClassLoader類的loadClass方法加載一個類,並不是對類的主動使用,不會導致類的初始化

class com.example.demo.com.jvm.CL
-----------------
Class cl
class com.example.demo.com.jvm.CL
 */

不同的類加載器作用與動作分析

隱式加載：程序在運行過程中碰到通過new等方式生成對象時，隱式調用類裝載器加載對應的類到jvm中
顯式裝載：通過class.forname()等方法，顯示加載需要的類
類加載的動態體現
一個應用程序總是由n多個類組成，Java程序啓動時，並不是一次把所有的類全部加載後再運行，它總是先把保證程
序運行的基礎類一次性加載到jvm中，其它類等到jvm用到的時候再加載，這樣的好處是節省了內存的開銷，因爲java
最早就是爲嵌入式系統而設計的，內存寶貴，這是一種可以理解的機制，而用到時再加載這也是java動態性的一種體
現
public static ClassLoader getSystemClassLoader();獲取系統類加載器

返回用於委派的系統類加載器
getParent() 返回父類加載器進行委派。

public class Test13 {
    public static void main(String[] args) {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();//獲取系統類加載

        System.out.println(classLoader);

        while (null != classLoader) {
            classLoader = classLoader.getParent(); //獲取父加載器 因爲使用根加載器時 返回值是用null來表示 所以循環結束
            System.out.println(classLoader);
        }


    }
}

/*
jdk自帶 的三個類加載器
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1eb44e46
null 並沒有繼承classLoader
*/

public class Test14 {
    public static void main(String[] args) throws IOException {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();//獲取當前線程的上下文類加載器 通常是獲取那個用於啓動應用的類加載器

        String res = "com/example/demo/com/jvm.Test13.class";

        Enumeration<URL> resource = classLoader.getResources(res);//獲取 類的資源
        while (resource.hasMoreElements()) {
            URL url = resource.nextElement();
            System.out.println(url);
        }

        System.out.println("--------獲取類加載器的有對應的的類-----------");

        Class<Test14> test14Class = Test14.class;
        System.out.println(test14Class.getClassLoader()); //sun.misc.Launcher$AppClassLoader@18b4aac2

    }
}

獲取類加載器的幾種方法

【JVM類加載】第二天類的初始化和類加載器雙親委託機制

類的初始化

類的初始化步驟

類的初始化時機

類加載器雙親委託機制詳解

不同的類加載器作用與動作分析

Python 潮流週刊#52：Python 處理 Excel 的資源

String類使用陷阱深度解析

java原生數據類型及其使用陷阱

lambda表達式：Java.util.function包下Bifunction，Predicate，Supplier，BinaryOperator函數式接口解析

【JVM類加載】第四天自定義類的複雜加載以及命名空間詳細學習以及總結類加載器的好處

【JVM類加載】第二天類的初始化和類加載器雙親委託機制

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結