单例模式

最简单版(饿汉式)。 通过static的静态初始化方式，在该类第一次被加载的时候，该对象的实例就被创建出来了

public class Singleton {
    //实例化
    private static Singleton instance = new Singleton();
    //私有构造方法
    private Singleton(){}
    //对外提供获取实例的静态方法
    public static Singleton getInstance() {
        return instance;
    }
}

第一种方式，如果较多的单例采用上述方式的话，可以回造成不必要的浪费。可采用另外两种方式来避免该种情况

 

静态内部类方式，通过显式调用方法是，才会装载单例对象，从而实例化

public class Singleton {
    //在静态内部类中初始化实例对象
    private static class InnerSingleton {
        private static final Singleton instance = new Singleton();
    }
    //私有构造方法
    private Singleton(){}
    //获取实例的静态方法
    public static Singleton getInstance() {
        return InnerSingleton.instance;
    }
}

懒汉模式方式

public class Singleton {
    //实例
    private static Singleton instance;
    //私有构造方法
    private Singleton(){}
    //获取实例的静态方法
    public static Singleton getInstance() {
        if(instance == null) {
　　　　　　synchronized(Singleton.class) {

               if(instance == null) {

                   instance = new Singleton();

               }

　　　　　　}
            
        }
        return instance;
    }
}

网上说序列化的情况下，可能会破坏单例，解决方法是重写readResolve方法。没有试验过

public class Singleton implements Serializable{
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
}