深度重学JAVA静态内部类的加载时机

单例模式

在看单例设计模式的时候，推荐使用内部类的这种方式

public class Singleton{
    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }
    
    private Singleton(){
        
    }
    
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

JVM加载类的过程都很清楚，一个类的静态资源，一些常量都是在类加载的时候就进行了内存分配，所以内部类的静态成员和静态内部类我理解也是这个样子，但是单例使用静态内部类，实现了懒加载，于是对前面的理解产生了疑问，为了验证这个疑问，做了一些加载测试

测试代码

public class OuterClass {
    public static Long outStaticValue = System.currentTimeMillis();
    public static int staticVal = 10;


    static {
        System.out.println("out class static block " + System.currentTimeMillis());
        System.out.println("out class static val " + staticVal);
    }

    public OuterClass() {
        System.out.println("out class init " + System.currentTimeMillis());
    }

    static class InnerStaticClass {
        public static Long innerClassStaticProperty = System.currentTimeMillis();

        static {
            System.out.println("inner static class static block " + System.currentTimeMillis());
        }

        public static String getInstance() {
            return "instance " + System.currentTimeMillis();
        }
    }

    class InnerClass {
        public long innerClassProperty = 0;

        static {
            System.out.println("inner class static block " + System.currentTimeMillis());
        }

        public InnerClass() {
            this.innerClassProperty = System.currentTimeMillis();
        }
    }
}

1.实例化外部类

public static void main(String[] args) {
    OuterClass outerClass = new OuterClass();
}
==========================输出===============================
out class static block 1721204602314
out class static val 10
out class init 1721204602324

当实例化外部类的时候，外部类静态代码块在类被加载时执行并且执行了初始化操作调用了构造方法，静态内部类没有任何动作

2.调用外部类的静态变量

public static void main(String[] args) {
    System.out.println("out class static property " + OuterClass.outStaticValue);
}
==========================输出===============================
out class static block 1721204646781
out class static val 10
out class static property 1721204646781

调用外部类的静态变量，外部类静态代码块在类加载时执行并且执行了初始化操作，没有初始化操作，没有调用构造函数，静态内部类没有任何动作

3.调用非静态内部类变量

public static void main(String[] args) {
    OuterClass outerClass = new OuterClass();
    System.out.println("inner class property "+ outerClass.new InnerClass().innerClassProperty);;
}
==========================输出===============================
out class static block 1721206521247
out class static val 10
out class init 1721206521260
inner class static block 1721206521262
inner class property 1721206521262   

• 在外部类的方法或代码块中，通过 new 关键字创建内部类的实例，需要先有一个外部类的实例。

调用非静态内部类变量，首先是外部类的静态代码块和构造函数调用，然后是非静态外部类的静态代码块和静态变量，静态变量和静态代码块同时加载

4.调用内部静态类的静态变量

public static void main(String[] args) {
    System.out.println("inner static class property " + InnerStaticClass.innerClassStaticProperty);
}
===============================输出===================================
out class static block 1721207135487
out class static val 10
inner static class static block 1721207135500
inner static class property 1721207135500

调用内部静态类的静态变量，首先加载执行外部类的静态块，然后加载静态内部类的静态块，外部类没有初始化

5.调用内部静态类的静态方法

public static void main(String[] args) {
    System.out.println("inner static class method " + InnerStaticClass.getInstance());
}
===============================输出===================================
out class static block 1721207177197
out class static val 10
inner static class static block 1721207177213
inner static class method instance 1721207177213

调用内部静态类的静态方法，首先加载执行外部类的静态块，然后加载静态内部类的静态块，外部类没有初始化

总结

经过上面代码的测试，可以得到一下结论，静态内部类和非静态内部类一样，都不会因外部类的加载而加载，同时静态内部类的加载不需要依附外部类，在使用时再加载，实现了懒加载，同时类的加载JVM有加载的机制，同时也实现了并发安全，但是尽管静态内部类可以不依赖外部类实现懒加载，但是加载静态内部类的同时也会加载外部类