静态内部类实现单例模式---基础到深入基础知识：实例的初始化过程是先初始化类对象，然后再初始化实例对象。如果此类存在超类

静态内部类实现单例的实现

//使用说明
public static void main(String[] args){
    Singleton single = Singleton.getIntance();
}

public class Singleton {    
 private Singleton() {}    
 private static class Holder {    
  // 这里的私有没有什么意义    
  /* private */static Singleton instance = new Singleton();    
 }
 public static Singleton getInstance() {    
  // 外围类能直接访问内部类（不管是否是静态的）的私有变量    
  return Holder.instance;    
 }    
}

先抛出个问题：

类Holder中的 instance在什么时候初始化？（程序一开始执行时？还是按需加载？）
对象的初始化大致的过程？是先初始化类对象，还是先初始化类的实例对象？
静态内部类的初始化过程又是怎样子的？

针对上面的问题一一来讲解：

基础知识：实例的初始化过程是先初始化类对象，然后再初始化实例对象。如果此类存在超类（父类），那么先初始化超类，然后再初始化自己。例子：

class A {
    private P p1 = new P("A--p1");
    static P p3 = new P("A--p3");

    public A() {
        System.out.println("A()");
    }

    private P p2 = new P("A--p2");

    static {
        new P("A--static");
    }

    {
        new P("A{...}");
    }

}

class P {
    public P(String s) {
        System.out.println(s);
    }
}

上面存在两个类：Class A 和 Class P, Class A 中存在静态的成员变量，静态的初始化快，私有成员变量，初始化快，构造器。如果此时我进行new A() , 那么打印的结果是怎样子的呢？

//结果如下：
A--p3
A--static
//----------------
A--p1
A--p2
A{...}
A()

我在结果中特意用了横线分割是想说明：横线上面部分为类初始化的打印，下面部分为类的实例初始化的打印。怎么验证呢？

//我们可以使用反射给我们提供的一个API : Class.forName(String name);
//此api用来初始化类对象
那么如果我在代码中初始化A类结果如何呢？
Class.forName("A");
/**
*结果如下：
* A--p3
* A--static
*/

上面的结果很明显验证了我们的猜想，先进行类对象初始化，然后再进行类实例对象初始化，下面为详细的初始化过程：

在类对象进行初始化的时候，按顺序会初始化类中的静态成员变量，静态初始化块。
在进行类实例初始化的时候，按顺序会初始化成员变量，初始化块，构造函数

那如果是静态内部类的初始化又是怎样子的呢？

class A {
    private P p1 = new P("A--p1");
    static P p3 = new P("A--p3");

    public A() {
        System.out.println("A()");
    }

    private P p2 = new P("A--p2");

    static {
        new P("A--static");
    }

    {
        new P("A{...}");
    }

    public static class C {
        private P p1 = new P("C--p1");
        static P p3 = new P("C--p3");

        public C() {
            System.out.println("C()");
        }

        private P p2 = new P("C--p2");

        static {
            new P("C--static");
        }

        {
            new P("C{...}");
        }
    }
}

class P {
    public P(String s) {
        System.out.println(s);
    }
}

对比刚才的代码，我们在Class A中新增加了静态内部类 Class C

//执行
new A.C();

上面的代码执行的结果大家的猜想是怎样子的？是先初始化类A，然后初始化类C，最后再构造一个类C的实例对象？无情的告诉你们结果：JVM是根据按需来初始化类的，此时我们的调用好像没有用到类A的信息。所以结果只是：初始化类C，最后构造了一个类C的实例对象。结果如下：

C--p3
C--static
//----------上面部分为类C初始化过程，下面为实例对象初始化过程
C--p1
C--p2
C{...}
C()

回到我们要讲的内容---静态内部类初始化过程

这个过程其实也是懒加载的过程，因为我们的程序没有访问静态内部类中的成员时，程序是不会进行该类初始化，直到我们调用的时候，才会进行初始化，才会存在JVM的堆中。为什么这种实现方式不用理会多线程的干扰，而增加synchronized同步机制呢？这是因为从始至终JVM只会持有一份类对象，全局的，不会受到多线程的干扰。而对象实例的话，就没有这个限制，想创建多少个都行，前提是内存充足的情况下。这种写法的好处：对比双重检查机制的单例模式，此种写法既简单又易懂，代码量还更少，所以推荐使用。

关于类在什么情况才被初始化，我在这里进行总结

Class.forName()
new 类()
访问类.静态成员
访问类.静态成员方法注意：类.class 这种写法是不会对相应的类进行初始化的，这里提个醒。