单例模式

创建者模式：单例模式（饿汉式/懒汉式/双重检测锁/静态内部类实现方法/枚举方式）
双重检测锁：有问题 。不去了解
饿汉式

/**
 * Copyright (C), 2020-2020
 * 描述：〈饿汉式〉 类初始化时候立即加载（没有延时加载的优势 类一创建就加载对象）， 由于加载类时候是线程安全的 方法没有同步 ，调用效率高。
 *
 * @author Administrator
 * @create 2020-5-17
 */
public class Single {
    //类初始化时候立即加载，
    private static Single instance =new Single();
    public Single() {
    }
    public static Single getInstance(){
        return  instance;
    }
}

懒汉式

/**
 * Copyright (C), 2020-2020
 * 描述：〈懒汉式〉 类延时加载， 存在线程安全问题 所以要加synchronized 修饰
 *
 * @author Administrator
 * @create 2020-5-17
 */
public class Single {
    //类初始化时候立即加载，
    private static Single instance;
    public Single() {
    }
    public static synchronized Single getInstance(){
        if (instance==null){
            instance=new Single();
        }
        
        return  instance;
    }
}

静态内部类式

/**
 * Copyright (C), 2020-2020
 * 描述：〈静态内部类式〉 类延时加载，
 *
 * @author Administrator
 * @create 2020-5-17
 */
public class Single {
    private static class SingleClassInstance {
        private static Single instance =new Single();
    }

    public Single() {
    }
    public static  Single getInstance(){
        return  SingleClassInstance.instance;
    }
}

枚举方式 ：枚举元素本身就是单例对象
避免了反射的漏洞 调用效率高 没有延时加载

/* *
 * Copyright (C), 2020-2020
 * 描述：〈枚举方式〉 没有延时加载，
 *
 * @author Administrator
 * @create 2020-5-17*/

public enum Single {
    INSTANCE;
    public void singleOperation() {
        //        功能处理方法
    }

}
 class SingleDemo{
    public static void main(String[] args) {
        Single instance = Single.INSTANCE;
    }
}

反射破解单例模式

Class clz=Class.forName("com.single");
Constructor  c=clz.getDeclaredConstryctor(null);
c.setAccessible(true);//访问私有权限
Single single=c.newInstance();
Single single2=c.newInstance();
//此时single和single2是两个不同的对象

解决反射破解问题

private Single（）{
	if（instnce！=null）{
	throw new RuntimeException（）
	}
}