单例设计模式

1. 单例：一个类只能有唯一一个实例对象；

2. 如何实现单例？
   1）饿汉式：不论使用者是否需要这个对象，都直接先创建好这个对象；

   //① 枚举
   public class SingletonPattern1 {
   
       public static void main(String[] args) {
           SingleEnum singleEnum1 = SingleEnum.INSTANCE;
           SingleEnum singleEnum2 = SingleEnum.INSTANCE;
           System.out.println(singleEnum1==singleEnum2);//true
       }
   }
   enum SingleEnum{
       INSTANCE
   }

   //② 构造器私有化，用全局的静态变量来保存这个唯一的实例对象；
   
   public class SingletonPattern2 {
   
   public static void main(String[] args) {
   
           Single single1 = Single.INSTANCE;
           Single single2 = Single.INSTANCE;
       
           System.out.println(single1==single2);//true
       }
   }
   
   class Single{
   
       public static final Single INSTANCE = new Single();
   
       private Single(){
   
       }
   }

   //③ 构造器私有化，用私有的静态称量来保存这个唯一的实例对象，提供静态方法返回这个常量对象；
   public class SingletonPattern3 {
   
   public static void main(String[] args) {
   
           SingleClass single1 = SingleClass.getInstance();
           SingleClass single2 = SingleClass.getInstance();
           System.out.println(single1==single2);//true
       }
   }
   
   class SingleClass{
       private static final SingleClass INSTANCE = new SingleClass();
   
       private SingleClass(){
   
       }
       public static SingleClass getInstance(){
           return INSTANCE;
       }
   }

   2）懒汉式：延迟创建对象，只有当使用者使用的时候才来创建这个对象；

   //① 普通形式
   public class SingletonPattern4 {
       public static void main(String[] args) {
   
           SingleClass4 single1 = SingleClass4.getINSTANCE();
           SingleClass4 single2 = SingleClass4.getINSTANCE();
           System.out.println(single1==single2);
       }
   }
   
   class SingleClass4{
       private static SingleClass4 INSTANCE;
       private SingleClass4(){
   
       }
   
       public static SingleClass4 getINSTANCE(){
   
           if (INSTANCE == null) { //提高效率
               synchronized (SingleClass4.class) { // 保证线程安全
                   if (INSTANCE == null) { // 判断 实现单例
                       INSTANCE = new SingleClass4();
                   }
               }
           }
           return INSTANCE;
       }
   }    

   //② 内部类形式：
   public class SingletonPattern5 {
       public static void main(String[] args) {
   
           SingleClass5 s1 = SingleClass5.getINSTANCE();
           SingleClass5 s2 = SingleClass5.getINSTANCE();
           System.out.println(s1==s2);
       }
   }
   class SingleClass5{
   
       // 私有化构造器
       private SingleClass5(){
   
       }
       // 创建内部类 创建外部类的唯一对象；
       static class Inner{
           private static final SingleClass5 INSTANCE = new SingleClass5();
       }
       // 定义方法提供类对象
       public static SingleClass5 getINSTANCE(){
           return Inner.INSTANCE;
       }
   }

声明：本文章是自学后编写，仅供参考，如有疏漏之处感谢指正；