關於類的加載機制和反射機制只看這一篇就夠了，分析的很是詳細

類加載機制的原理

1.啓動JVM
2.將須要運行的class文件加載到虛擬機內存中
3.找到主類，開始執行主函數

加載步驟：

1.先委託父類加載類，若是父類已經加載，就不須要再次加載，若是父類沒有加載，再由本加載器加載
2.解析類路徑，將類路徑轉換成文件路徑
3.經過文件輸入流來讀取class文件，獲得字節數組
4.將字節數組轉換成類對象,對象的類型是Class類型

有哪些類加載器

類加載器：ClassLoader
AppClassLoader： 應用類加載器，負責加載核心類，加載本身寫的類
ExtClassLoader： 擴展類加載器，負責加載擴展類庫
bootstrap： JVM內置的加載器
Bootstrap類加載器是JVM的一部分，是由C++編寫的，隨着啓動虛擬機就會建立一個bootstrap類加載器對象

得到Class對象的幾種方式

1.經過類名.class

Class c1 = Student.class;

2.經過對象的getClass()方法

Class c2 = stu.getClass();

3.經過類加載器得到class對象

ClassLoader classLoader = ClassLoader.getSystemClassLoader();
Class c3 = classLoader.loadClass("com.newer.test.Student");

4.經過 Class.forName()得到Class對象;

Class c4 =  Class.forName("com.newer.test.Student");

總代碼：
先建立學生類

package com.newer.test;

public class Student {
    private int num;
    private String name;
    private int age;
    public Student(){
    }
    private Student(int num){
        this.num = num;
    }
    public Student(int num,String name,int age){
        this.num = num;
        this.name = name;
        this.age = age;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.newer.test;

public class MainClass {
    public static void main(String[] args) throws  Exception{

        Student stu = new Student();

        //得到Student的Class對象

        //1.經過類名.class
        Class c1 = Student.class;

        //2.經過對象的getClass()方法
        Class c2 = stu.getClass();

        //3.經過類加載器得到class對象
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        Class c3 = classLoader.loadClass("com.newer.test.Student");

        //4.經過 Class.forName()得到Class對象;
        Class c4 = Class.forName("com.newer.test.Student");

如何經過Class對象得到構造方法對象

類的全部的信息都在Class對象中
Class類是反射機制中的核心類

Class c = Class.forName(包名.類名);

//加載類，得到類的Class對象
Class c = Class.forName("com.newer.test.Student");

1.得到全部可見的構造方法

//1.得到全部可見的構造方法
Constructor[] cons= c.getConstructors();

2.得到全部已經聲明的構造方法

//2.得到全部已經聲明的構造方法
Constructor[] cons2= c.getDeclaredConstructors();

3.得到指定的可見的某一個構造方法

//3.得到指定的可見的某一個構造方法
Constructor cc = c.getConstructor(int.class,String.class,int.class);

4.從聲明的方法中得到指定的構造方法

//4.從聲明的方法中得到指定的構造方法
Constructor cc2 = c.getDeclaredConstructor(int.class);

總代碼：
學生類

package com.newer.test;

public class Student {
    private int num;
    private String name;
    private int age;
    public Student(){
    }
    private Student(int num){
        this.num = num;
    }
    public Student(int num,String name,int age){
        this.num = num;
        this.name = name;
        this.age = age;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.newer.test;

import java.lang.reflect.Constructor;
/**
 * 反射機制動態得到類的信息
 */
public class FanShe {
    public static void main(String[] args) throws Exception{
        //加載類，得到類的Class對象
        Class c = Class.forName("com.newer.test.Student");
        //經過Class對象得到類的信息
        //1.得到全部可見的構造方法
        Constructor[] cons= c.getConstructors();
        for (Constructor con:cons){
            System.out.println(con);
        }
        System.out.println("------------------------");
        //2.得到全部已經聲明的構造方法
        Constructor[] cons2= c.getDeclaredConstructors();
        for (Constructor con:cons2){
            System.out.println(con);
        }
        System.out.println("------------------------");
        //3.得到指定的可見的某一個構造方法
        Constructor cc = c.getConstructor(int.class,String.class,int.class);
        System.out.println(cc);
        System.out.println("------------------------");
        //4.從聲明的方法中得到指定的構造方法
        Constructor cc2 = c.getDeclaredConstructor(int.class);
        System.out.println(cc2);
        System.out.println("------------------------");
      }
}

如何經過構造方法對象實例化

//經過構造方法對象獲得類的實例對象
Object obj = cc.newInstance(123,"zhangsan",20);

訪問私有構造方法：
cc2.setAccessible(true);

//經過私有構造方法實例化對象
//設置容許訪問私有構造方法
cc2.setAccessible(true);
Object obj2 =  cc2.newInstance(22);

最後

感謝你看到這裏，看完有什麼的不懂的能夠在評論區問我，以爲文章對你有幫助的話記得給我點個贊，天天都會分享java相關技術文章或行業資訊，歡迎你們關注和轉發文章！