静态内部类加载顺序

                                             静态内部类加载顺序
我们先来区分一下两个概念：类加载、加载。

类加载的过程包括加载，初始化，验证，解析，准备，初始化等五个过程。加载是类加载的一部分。

区分完这两个概念之后我们再来看下面的问题。

我们声明一个类，这个类有个内部静态类。还有主函数，当我们启动程序之后，运行java application程序。

运行结果是什么呢？

下面看个代码实现的例子：

package Test;
 
public class OuterClass {
    static {
        System.out.println("加载外部类");
    }
    static class InnerClass{
        public InnerClass() {}
        static {
            System.out.println("加载内部类");
        }
        static void innerMethod() {
            System.out.println("内部类的静态方法");
        }
        static int a;
    }
 
    public static void main(String[] args) {
        OuterClass out=new OuterClass();
        System.out.println("=============");
//        OuterClass.InnerClass.a=1;
    }
 
}

外部类的静态代码块执行了。内部类的静态代码块没有执行在外部类执行静态代码块之后执行，是因为内部类没有加载么？

其实不是这样的，一旦程序运行，所有该类涉及的类(包括内部类和从其他包导入的类)都会在类加载的过程中加载到

内存，因为在整个程序运行的过程中类加载只会发生一次，一旦某个类没有被加载，那么将不能再使用这个类。

注意我标出来的加载，这里是指在类加载过程中的加载，但是我们可以在网上了解或者在书上得知，只有当某个类

初始化之后，才会调用类的静态代码块。才会执行对应的。那么什么时候执行类加载过程中的类初始化呢？

只有当我们有对类的引用的时候，才会将类初始化。

比如我们new一个非静态类的对象，或者对某个静态类的成员(包括成员方法和域)或者调用有访问的时候

如果我们把最后一行的注释去掉，就会执行内部静态类的静态代码块(static{})。

或者有隐式的调用我们类的方法。为什么我们的外部类没有new的时候还会执行他的静态代码块呢？

是不是忘了还有个主函数在执行，这时候是调用了类的方法的，所以会初始化这个外部类。执行外部类的静态代码块。

关于静态代码块，代码块，类的构造函数执行顺序问题不态理解的同学可以看看我的博客：

Java面试题 类的构造函数的执行顺序问题

注意：内部静态类不会自动初始化，只有调用静态内部类的方法，静态域，或者构造方法的时候才会加载静态内部类。

利用这种特点我们可以实现一个单例模式

package Test;
 
public class Single {
    
    private Single() {}
    
    static class SingleHolder {
        
        private static final Single instance=new Single(); 
        
    }
    public static Single getinstance() {
        return SingleHolder.instance;
    }
 
    public static void main(String[] args) {
        
        Single a=Single.getinstance();
        Single b=Single.getinstance();
        Single c=Single.getinstance();
        System.out.println(a.toString());
        System.out.println(b.toString());
        System.out.println(c.toString());
    }
 
}

上面程序的运行结果：

当我们用的构造方法声明为private的时候，代表这个类只能被自己调用，就算同包下的类也不能实例化。

这并不是构造函数只会被调用一次，并且保证只会实例化一次类的原因。如果你把上面的构造函数变成public，

也是只生成一个对象。

上面的例子是说这个外部类的对象被内部类当成内部类的静态final域，所以只会有一个。