- 静态内部类实现单例的实现
//使用说明
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 这种写法是不会对相应的类进行初始化的，这里提个醒。
