Java注解和反射（三）类加载过程

今天药忘吃喽~ 2022-11-04 00:56 193阅读 0赞

## 前言 ##

学习了类加载过程，可以更加方便我们理解反射的机制和原理。没兴趣的同学可直接跳过该篇。

### 一、类加载过程 ###

##### 1、加载（load） #####

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类地java.lang.Class对象。

##### 2、链接（link） #####

将类的二进制数据合并到 JRE 中。

*  验证：确保加载的类信息符合JVM规范，没有安全方面的问题
 *  准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
 *  解析：虚拟机常量池的符号引用（常量名）替换为直接引用（地址）的过程

##### 3、初始化（Initialize）：JVM虚拟机负责对类进行初始化 #####

*  执行类构造器()方法的过程。类构造器()方法是由编译期间自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
 *  当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先出发其父类的初始化
 *  虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

图示如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70_pic_center]  
测试代码：

public class test01 { 
        public static void main(String[] args) { 
            A a = new A();
            System.out.println(A.num);
        }
    }
    class A{ 
        static { 
            System.out.println("静态代码块初始化！");
            num = 500;
        }
        static Integer num = 100;
        public A(){ 
            System.out.println("无参构造初始化！");
        }
    
    }

执行结果如下：  
![在这里插入图片描述][20210301105256267.png]  
结论：  
①先执行静态代码块，这时候给num赋值为500  
②然后执行无参构造函数，其实就是我们new的操作。  
③执行num = 100；  
④可以简单的得出类的加载先后顺序！

##### 二、类初始化 #####

前置代码：

public class test01 { 
        static { 
            System.out.println("我是main类的静态代码块。main类被加载啦~");
        }
        public static void main(String[] args) { 
            
        }
    }
    class A{ 
        static int b = 2;
        static { 
            System.out.println("父类A被加载~");
        }
    }
    class B extends A{ 
        static { 
            System.out.println("子类B被加载~");
            b = 500;
        }
        static int m = 100;
        static final int M = 1;
    }

可以分两种情况来讨论这个问题：  
1、类的主动引用（一定会发生类的初始化）

*  当虚拟机启动，先初始化main方法所在的类
 *  new一个类的对象
 *  调用类的静态成员（除了final常量）和静态方法
 *  使用java.lang.reflect包的方法对类进行反射调用
 *  当初始化一个类，如果其父类没有被初始化，则先会初始化他的父类

public static void main(String[] args) { 
    		//主动引用
            B b = new B();
        }

结果：  
![在这里插入图片描述][20210301110525706.png]

public static void main(String[] args) { 
    		//反射也会产生主动引用
           Class.forName("com.dbright.Test.B");
        }

![在这里插入图片描述][20210301110800713.png]

2、类的被动引用（不会发生类的初始化）

*  当访问一个静态域时，只有真正声明这个域的类才会被初始化，如：当通过子类引用父类的静态变量，不会导致子类初始化
 *  通过数组定义类引用，不会触发此类的初始化
 *  引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

public static void main(String[] args) { 
    		//调用父类静态变量
          System.out.println(B.b);
        }

![在这里插入图片描述][20210301111112732.png]

public static void main(String[] args) { 
    		//定义自身数组
          B[] array = new B[5]; 
        }

![在这里插入图片描述][2021030111114973.png]

public static void main(String[] args) { 
    		//调用自身静态变量
          System.out.println(B.M);
        }

![在这里插入图片描述][20210301111303966.png]

##### 三、类加载器 #####

类加载器的**作用**：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中数据的访问入口。  
类加载器主要分为三层：

*  **引导类加载器：** 用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取 Java\\jdk1.8\\jre\\lib\\rt.jar
 *  **扩展类加载器：** 负责jre/lib/ext目录下的jar包或 -D java.ext.dirs 指定目录下的jar包装入工作库
 *  **系统类加载器：** 负责java -classpath 或 -D java.class.path 所指目录下的类与jar包装入工作，是最常用的加载器

**类缓存：** 标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，他将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以回收这些Class对象。

public class Test02 { 
        public static void main(String[] args) throws ClassNotFoundException { 
            //获取系统类的加载器
            ClassLoader loader = ClassLoader.getSystemClassLoader();
            System.out.println(loader);  //sun.misc.Launcher$AppClassLoader@18b4aac2
    
            //获取系统类加载的父类加载器-->扩展类加载器
            ClassLoader parent = loader.getParent();
            System.out.println(parent);  //sun.misc.Launcher$ExtClassLoader@74a14482
    
            //获取扩展类加载器的父类加载器-->根加载器（C/C++）
            ClassLoader parent1 = parent.getParent();
            System.out.println(parent1);  //null
    
            //测试当前类是哪个加载器加载的
            ClassLoader classLoader = Class.forName("com.dbright.Test.Test02").getClassLoader();
            System.out.println(classLoader);  //sun.misc.Launcher$AppClassLoader@18b4aac2
    
            //测试JDK内部类是谁加载的
            classLoader = Class.forName("java.lang.Object").getClassLoader();
            System.out.println(classLoader);  //null
    
            // 如何获取系统类加载器可以加载的路径
            System.out.println(System.getProperty("java.class.path"));
            /* D:\Software\Java\jdk1.8\jre\lib\charsets.jar; D:\Software\Java\jdk1.8\jre\lib\deploy.jar; D:\Software\Java\jdk1.8\jre\lib\ext\access-bridge-64.jar; D:\Software\Java\jdk1.8\jre\lib\ext\cldrdata.jar; D:\Software\Java\jdk1.8\jre\lib\ext\dnsns.jar; D:\Software\Java\jdk1.8\jre\lib\ext\jaccess.jar; D:\Software\Java\jdk1.8\jre\lib\ext\jfxrt.jar; D:\Software\Java\jdk1.8\jre\lib\ext\localedata.jar; D:\Software\Java\jdk1.8\jre\lib\ext\nashorn.jar; D:\Software\Java\jdk1.8\jre\lib\ext\sunec.jar; D:\Software\Java\jdk1.8\jre\lib\ext\sunjce_provider.jar; D:\Software\Java\jdk1.8\jre\lib\ext\sunmscapi.jar; D:\Software\Java\jdk1.8\jre\lib\ext\sunpkcs11.jar; D:\Software\Java\jdk1.8\jre\lib\ext\zipfs.jar; D:\Software\Java\jdk1.8\jre\lib\javaws.jar; D:\Software\Java\jdk1.8\jre\lib\jce.jar; D:\Software\Java\jdk1.8\jre\lib\jfr.jar; D:\Software\Java\jdk1.8\jre\lib\jfxswt.jar; D:\Software\Java\jdk1.8\jre\lib\jsse.jar; D:\Software\Java\jdk1.8\jre\lib\management-agent.jar; D:\Software\Java\jdk1.8\jre\lib\plugin.jar; D:\Software\Java\jdk1.8\jre\lib\resources.jar; D:\Software\Java\jdk1.8\jre\lib\rt.jar; D:\NEU\learn\java\project\out\production\project; D:\NEU\learn\java\project\src\com\lib\commons-io-2.8.0.jar; D:\Software\IntelliJ IDEA 2020.1.4\lib\idea_rt.jar */
            //双亲委派机制：如果上层加载器存在不会使用下层定义类
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]  
**双亲委派机制：如果上层加载器存在不会使用下层定义类**

Java注解和反射扩展：[Java注解和反射学习汇总][Java]

***路漫漫其修远兮，吾必将上下求索~***  
如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧\*\*转载请注明出处哦\*\*

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/6c5a638c246a4c6f86da4976c0486a2b.png
[20210301105256267.png]: /images/20221023/1ed990532de447c59f7f3fb0fde40a9e.png
[20210301110525706.png]: /images/20221023/85accfa4a6e84059b4a310db2d4eb035.png
[20210301110800713.png]: /images/20221023/33b1dbb5645646499e60c69fd637608b.png
[20210301111112732.png]: /images/20221023/2abf9685164d4a4782a4a894f7e051fa.png
[2021030111114973.png]: /images/20221023/2c76d1e60e654f57a91aa06f12938871.png
[20210301111303966.png]: /images/20221023/f7ec6abd43204462acff29f588b680ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyOTQ0Mw_size_16_color_FFFFFF_t_70]: /images/20221023/ee6f0cf689044faf957ceeec803486e8.png
[Java]: https://blog.csdn.net/weixin_43829443/article/details/114089405