设计模式-单例模式

1.懒汉模式

public class LazySingleton {

    private volatile static LazySingleton instance;

    private LazySingleton() {

    }

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

    public static void main(String[] args) {
        System.out.println(LazySingleton.getInstance());
    }
}

使用场景：

数据源连接

2.饿汉模式

public class HungrySingleton {

    private static HungrySingleton instance = new HungrySingleton();

    private HungrySingleton(){

    }

    public static HungrySingleton getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(HungrySingleton.getInstance());
    }
}

使用场景：

3.静态内部类

public class InnerClassSingleton {
    /**
     * 静态内部类
     */
    private static class InnerClass {
        private static InnerClassSingleton innerClass = new InnerClassSingleton();
    }

    private InnerClassSingleton(){
        if (InnerClass.innerClass != null){
            throw new RuntimeException("实例已经存在了");
        }
    }

    public static InnerClassSingleton getInstance() {
        return InnerClass.innerClass;
    }

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        System.out.println(InnerClassSingleton.getInstance());
        Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();
        System.out.println(InnerClassSingleton.getInstance() == innerClassSingleton);
    }
}

在使用单例模式的时候，可以使用反射破解单例模式；

不过也有解决方案，即是在私有的构造函数里面做非空判断，如果已经有实例了就抛出异常。所以防止单例被破坏的模式只有 静态内部类 和 恶汉模式

创建类的五种方式：

1.new一个；

2.clone方式；

3.通过class的newInstance

4.通过反序列化

5.通过Constructor的newInstance