单例模式，太全了

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 其中除枚举以外的其他方法，枚举方式是因为有enum语法糖，JVM会阻止反射获取枚举类的私有构造方法
 * 因为当一个对象在序列化->反序列化之后，JVM就会出现一个相同的对象，
 * 这个时候，需要调用readResolve()方法来维护单例模式
 *
 * 枚举语法糖详解：https://blog.csdn.net/iteye_2730/article/details/82476299
 * 
 * @author King
 * @since 2021/5/28 13:42
 */
public class SingleClass {

    public static void main(String[] args) {
        EagerClass instance = EagerClass.getInstance();
        System.out.println(instance.getClass().getName());
    }

}

//处理反序列化出现相同对象的单例模式
final class ReadResolveSingletonClass implements Serializable {
    private ReadResolveSingletonClass() {
    }

    private static final ReadResolveSingletonClass INSTANCE = new ReadResolveSingletonClass();

    public static ReadResolveSingletonClass getInstance() {
        return INSTANCE;
    }
    //readResolve() 防止反序列化克隆对象
    private Object readResolve() throws ObjectStreamException {
        return INSTANCE;
    }
}

//每次用到的时候才会去创建，会有线程安全问题，需要加入synchronized
class LazyClass {
    private static LazyClass lazyClass;

    private LazyClass() {
    }

    public static LazyClass getInstance() {
        if (lazyClass == null) {
            lazyClass = new LazyClass();
        }
        return lazyClass;
    }
}

//每次在初始化实例的时候就创建好了。没有线程安全问题，但是会浪费空间
class EagerClass {
    private static EagerClass eagerClass = new EagerClass();

    private EagerClass() {
    }

    public static EagerClass getInstance() {
        return eagerClass;
    }
}

// 双检索，结合懒汉式和饿汉式，既保证安全又不浪费空间
class DoubleCheckClass {
    private static DoubleCheckClass doubleCheckClass;

    private DoubleCheckClass() {
    }

    public static DoubleCheckClass getInstance() {
        if (doubleCheckClass == null) {
            synchronized (DoubleCheckClass.class) {
                if (doubleCheckClass == null) {
                    doubleCheckClass = new DoubleCheckClass();
                }
            }
        }
        return doubleCheckClass;
    }
}

//静态内部类的方式，类似双检索。这种方式只适用于静态域，双检索可以实现延迟初始化
class StaticSingleClass {
    private static class StaticSingleClassHolder {
        private static final StaticSingleClass STATIC_SINGLE_CLASS = new StaticSingleClass();
    }

    private StaticSingleClass() {
    }

    public static final StaticSingleClass getInstance() {
        return StaticSingleClassHolder.STATIC_SINGLE_CLASS;
    }
}

//volatile防止指令重排序
class SingletonVolatileClass {
    private SingletonVolatileClass() {
    }  //私有构造函数

    private volatile static SingletonVolatileClass instance = null;  //单例对象

    //静态工厂方法
    public static SingletonVolatileClass getInstance() {
        if (instance == null) {      //双重检测机制
            synchronized (SingletonVolatileClass.class) {  //同步锁
                if (instance == null) {     //双重检测机制
                    instance = new SingletonVolatileClass();
                }
            }
        }
        return instance;
    }
}

//枚举方式，可以防止反射强行构建单例对象，也可以在枚举类对象被发序列化的时候，保证反序列返回的结果是同一对象
enum EnumClass {
    INSTANCE;

    public void anyMethod() {
    }
}