Java-类加载器-加载时机

青旅半醒 2023-10-09 05:25 75阅读 0赞

## 什么时候会出发类加载器？ ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][]

## 创建类的实例 ##

为了验证类加载，我们先配置一个JVM参数

-XX:+TraceClassLoading 监控类的加载

在IDE配置如下：

![format_png][]

代码：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: ClassLoadInstance
     **/
    public class ClassLoadInstance {
    
        static {
            System.out.println("ClassLoadInstance类初始化时就会被执行！");
        }
    
        public ClassLoadInstance() {
            System.out.println("ClassLoadInstance构造函数！");
        }
    }
    
    class ClassLoadInstanceTest {
    
        public static void main(String[] args) {
            ClassLoadInstance instance = new ClassLoadInstance();
        }
    }

结果：

![20190925112015790.png][]

**结论：**

new ClassLoadInstance实例时，发现ClassLoadInstance被加载了，因此 new创建实例对象，会触发类加载进行。

--------------------

##  访问类的静态变量 ##

代码：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: ClassLoadInstance2
     **/
    public class ClassLoadStaticVariable {
    
        static {
            System.out.println("ClassLoadStaticVariable类初始化时就会被执行！");
        }
    
        public static int i = 100;
    
        public ClassLoadStaticVariable() {
            System.out.println("ClassLoadStaticVariable构造函数！");
        }
    
    }
    
    
    class ClassLoadStaticVariableTest {
    
        public static void main(String[] args) {
            System.out.println(ClassLoadStaticVariable.i);
        }
    }

结果：

![20190925112319958.png][]

**结论：**

访问类ClassLoadStaticVariable的静态变量i时，发现ClassLoadStaticVariable类被加载啦，因此访问类的静态变量会触发类加载。

**注意：**

访问final修饰的静态变量时，不会触发类加载，因为在编译期已经将此常量放在常量池了。

--------------------

## 访问类的静态方法 ##

代码：

package com.cdmt.java.annotation.historyhandler;
        
        public class ClassLoadStaticMethod {
        
            static {
                System.out.println("ClassLoadStaticMethod类初始化时就会被执行！");
            }
        
            public static void method(){
                System.out.println("静态方法被调用");
            }
        
            public ClassLoadStaticMethod() {
                System.out.println("ClassLoadStaticMethod构造函数！");
            }
        
        }
        
        class ClassLoadMethodTest{
        
            public static void main(String[] args) {
                ClassLoadStaticMethod.method();
            }
        }

结果：

![20190925112516794.png][]

结论：

访问类ClassLoadStaticMethod的静态方法method时，发现ClassLoadStaticMethod类被加载啦，因此访问类的静态方法会触发类加载

--------------------

##  反射： ##

代码：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: ClassLoadStaticReflect
     **/
    public class ClassLoadStaticReflect {
    
        static {
            System.out.println("ClassLoadStaticReflect类初始化时就会被执行！");
        }
    
        public static void method(){
            System.out.println("静态方法被调用");
        }
    
        public ClassLoadStaticReflect() {
            System.out.println("ClassLoadStaticReflect构造函数！");
        }
    
    }
    
    class ClassLoadStaticReflectTest {
        public static void main(String[] args) throws ClassNotFoundException {
            Class.forName("com.cdmt.java.annotation.historyhandler.ClassLoadStaticReflectTest");
            System.out.println("---------------");
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1][]

**结论：**

反射得到类ClassLoadStaticReflect时，发现ClassLoadStaticReflect类被加载啦，因此反射会触发类加载。

--------------------

##  当初始化一个类时，发现其父类还未初始化，则先触发父类的初始化： ##

代码：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: ClassLoadSuper
     **/
    //父类
    public class ClassLoadSuper {
        static {
            System.out.println("ClassLoadSuper类初始化时就会被执行！这是父类");
        }
    
        public static int superNum = 100;
    
        public ClassLoadSuper() {
            System.out.println("父类ClassLoadSuper构造函数！");
        }
    }
    //子类
    class ClassLoadSub extends ClassLoadSuper {
    
        static {
            System.out.println("ClassLoadSub类初始化时就会被执行！这是子类");
        }
    
        public static int subNum = 100;
    
        public ClassLoadSub() {
            System.out.println("子类ClassLoadSub构造函数！");
        }
    
    }
    
    class ClassLoadSuperTest {
    
        public static void main(String[] args) throws ClassNotFoundException {
            ClassLoadSub classLoadSub = new ClassLoadSub();
        }
    }

结果：

![20190925112906886.png][]

看了运行结果，是不是发现，网上那道经典面试题（**讲讲类的实例化顺序**？）也很清晰啦。 先父类静态变量/静态代码块-> 再子类静态变量/静态代码块->父类构造器->子类构造器

**结论：**

实例化子类ClassLoadSub的时候，发现父类ClassLoadSuper先被加载，因此当初始化一个类时，发现其父类还未初始化，则先触发父类的初始化

--------------------

## 虚拟机启动时，定义了main()方法的那个类先初始化： ##

代码：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: ClassLoadTest
     **/
    public class ClassLoadTest {
    
        public static void main(String[] args)  {
            System.out.println(ClassLoadSub.subNum);
        }
    }

结果：

![20190925113038852.png][]

**结论：**

虚拟机启动时，即使有ClassLoadSub，ClassLoadSuper，ClassLoadTest等类被加载， 但ClassLoadTest最先被加载，即定义了main()方法的那个类会先触发类加载。

--------------------

## 练习与小结： ##

触发类加载的六大时机，我们都分析完啦，是不是不做个题都觉得意犹未尽呢？接下来，我们来分析类加载一道经典面试题吧。

class SingleTon {  
        private static SingleTon singleTon = new SingleTon();  
        public static int count1;  
        public static int count2 = 0;  
      
        private SingleTon() {  
            count1++;  
            count2++;  
        }  
      
        public static SingleTon getInstance() {  
            return singleTon;  
        }  
    }  
      
    public class ClassLoadTest {  
        public static void main(String[] args) {  
            SingleTon singleTon = SingleTon.getInstance();  
            System.out.println("count1=" + singleTon.count1);  
            System.out.println("count2=" + singleTon.count2);  
        }  
    }

运行结果：

![format_png 1][]

**分析：**

1.  SingleTon.getInstance()，调用静态方法，触发SingleTon类加载（单例模式-饿汉式）。
2.  SingleTon类加载初始化，按顺序初始化静态变量。
3.  先执行private static SingleTon singleTon = new SingleTon(); ，调用构造器后，count1，count2均为1；
4.  按顺序执行 public static int count1; 没有赋值，所以count1依旧为1；
5.  按顺序执行 public static int count2 = 0;所以count2变为0.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190925111315924.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS85LzIyLzE2ZDU4Y2NmMjM5ZjE3ZDU_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png
[20190925112015790.png]: https://img-blog.csdnimg.cn/20190925112015790.png
[20190925112319958.png]: https://img-blog.csdnimg.cn/20190925112319958.png
[20190925112516794.png]: https://img-blog.csdnimg.cn/20190925112516794.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190925112722673.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9odWFuZ2hhaXRhby5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70
[20190925112906886.png]: https://img-blog.csdnimg.cn/20190925112906886.png
[20190925113038852.png]: https://img-blog.csdnimg.cn/20190925113038852.png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAxOS85LzIyLzE2ZDU5MmI2N2JmYmVkMzY_aW1hZ2VWaWV3Mi8wL3cvMTI4MC9oLzk2MC9mb3JtYXQvd2VicC9pZ25vcmUtZXJyb3IvMQ?x-oss-process=image/format,png