关于类的加载机制和反射机制只看这一篇就够了，分析的很是详细

类加载机制的原理

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相关技术文章或行业资讯，欢迎你们关注和转发文章！