单例模式--静态内部类和静态代码块实现单例的区别

静态资源不是一开始就存在于内存中的。

我们来看一个例子，静态资源不是一开始就存在于内存中的。

class A{
    private A(){
        System.out.println("A被初始化了");
    }
    private static A a = new A();
}

我们创建了一个类A，我们并没有使用这个类，在控制台，也不会输出：“A初始化了”，这样一句话。

静态内部类和静态代码块实现单例的区别

静态代码块实现单例模式，事实上就是懒汉单例模式的变种。

public class T{
    public static void main(String[] args) {
        Singleton.print();
        /*************/
        Singleton2.print();
    }
}


class Singleton{
    private static Singleton instance;
    private Singleton(){}
    static{
        System.out.println("Singleton--我在被调用的时候加载，而且只加载一次");
        instance = new Singleton();
    }
    public static Singleton getInstance(){
        return instance;
    }
    public static void print(){
        System.out.println("我只想调用这个方法，不想初始化实例对象");
    }
}

class Singleton2{
    private Singleton2(){}
    private static class Handler{
        static{
            System.out.println("Singleton2--我在调用的时候被加载，而且只加载一次");
        }
        private static Singleton2 instance = new Singleton2();
    }
    public static Singleton2 getInstance(){
        return Handler.instance;
    }
    public static void print(){
        System.out.println("我只想调用这个方法，不想初始化实例对象");
    }
}

输出结果：
Singleton–我在被调用的时候加载，而且只加载一次
我只想调用这个方法，不想初始化实例对象
我只想调用这个方法，不想初始化实例对象

很明显，这里在不想初始化的时候，它初始化了，所以是一种变种的饿汉单例模式。