• 设计模式——单例模式
  

一、介绍    

设计模式更多的是思想层面，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了使代码高可用，易于他人理解以及保证代码的可靠性。

    设计模式有23中：单例模式、抽象工厂模式、工厂模式、建造者模式、原型模式等。

    单例模式（使用单例模式就是为了保证整个应用中某个实例有且只有一个）：

         在程序开发中，有些对象只需要一个，比如：配置文件、工具类、线程池、缓存、日志对象等；如果创建多个对象，会导致很多问题，比如资源占用，结果不一致等等。

二、实现

单例模式（Singleton）：

    饿汉模式（静态成员属类所有，加载类时，就会创建类的唯一实例，不管用户是否使用这个实例，它已经被加载，形象的称之为“饿汉模式”）：

public class Singleton{
//默认的构造方法在创建对象时被调用；多次new则创建多个类对象
   //1、私有化构造方法(外部无法直接通过构造方法创建实例，避免创建多个实例)
   private Singleton(){}
   //2、保证实例只有一个，自己创建实例(创建类的唯一实例,使用private static修饰类的静态成员)
   //因外部类无法直接使用对象.成员方法()，所以使用static静态修饰对象，用类名.成员名创建实例
   //为了控制访问、安全，加private不允许外部访问成员变量，不能使用类名.成员名创建实例
   private static Singleton instance = new Singleton();
   //3、提供一个用于获取实例的方法(属于对象方法，不用static修饰的话无法用类名.方法创建实例)
   /*public Singleton getInstance(){
       return instance;
   }*/
   //使用public static修饰类方法
   public static Singleton getInstance(){
       return instance;
   }
}

public class Test{
   public static void main(String[] args){
       //私有化构造方法后，外部类无法直接创建实例
       
       /*Singleton s1 = Singleton.instance;//调用静态成员创建实例
       Singleton s2 = Singleton.instance;//调用静态成员创建实例
       if(s1==s2){//true  保证创建的Singleton对象是单个实例
           System.out.println("s1和s2是同一个实例");
       }else{
           System.out.println("s1和s2不是同一个实例");
       }*/
       //调用失败，方法是对象方法（没有用static修饰的方法）
       /*Singleton s1 = Singleton.getInstance();*/
       Singleton s1 = Singleton.getInstance();
       Singleton s2 = Singleton.getInstance();
       if(s1==s2){//true  保证创建的Singleton对象是单个实例
           System.out.println("s1和s2是同一个实例");
       }else{
           System.out.println("s1和s2不是同一个实例");
       }
   }
}

    懒汉模式（类加载时不创建唯一实例，当第一个用户获取时判断实例为空时时创建，之后所有用户获取已经存在的实例将不再创建）：

public class Singleton2{
   //1、私有化构造方法，不允许外部直接通过构造方法创建对象
   private Singleton2(){}
   //2、声明类的唯一实例，使用private static 修饰
   private static Singleton2 instance ;
   //3、提供一个用于获取实例的方法，使用public static修饰
   public static Singleton2 getInstance(){
       if(instance == null){
           instance = new Singleton2();
       }
       return instance;
   }
}

public class Test{
   public static void main(String[] args){
       Singleton2 s3 = Singleton2.getInstance();
       Singleton2 s4 = Singleton2.getInstance();
       if(s3==s4){//true  保证创建的Singleton对象是单个实例
           System.out.println("s3和s4是同一个实例");
       }else{
           System.out.println("s3和s4不是同一个实例");
       }
   }

 三、区别

        饿汉模式加载类时比较慢，运行时获取对象速度比较快，线程安全；

        懒汉模式加载类时比较快（加载类时没有创建类的对象），但运行时获取对象速度比较慢（用户第一次获取对象时由于类还没有被创建，需要创建对象的一个过程），线程不安全。

单例模式六种实现方式

声明实例和实例化 两种模式区别在实例化的地方不一样

对象方法和类方法： 类方法前加static，归类所有，其他类可以直接调用该方法

static 类的

设计模式，单例模式 笔记 1，设计模式的定义。 用你的人多了，一种反复使用的，多数人知晓的，方法的总结。 2 饿汉模式 1)控制不可以被外部直接实例化对象，使用private修饰构造函数。 2)私有化构造函数后，外部无法创建实例化对象，所以要实现唯一实例对象，通过类对象实现。 单纯的在类里实例化一个对象，该对象作为类成员，需要外部通过对象加点去获取，但是外部没有对象，就要通过添加static去将这个唯一实例化对象变成类的成员变量，通过类名的方式去获取该对象。 3)为了安全考虑，不允许外部直接访问类成员变量，给变量添加private修饰，此时，外部不可以通过类名直接访问这个对象。 再添加一个public访问函数，同理，只添加public为类的对象，无法外部直接使用。所以添加static修饰，变为类方法。 4)该方法，加载类的时候直接实例化一个对象，所以加载较慢，但是调用较快 3 懒汉模式 加载的时候不实例化，第一次调用的时候实例化。所以加载较快，使用较慢。 4 饿汉模式，线程安全 懒汉模式，线程不安全

懒汉模式

Singleton

Singleton 懒汉式

Singleton 饿汉式

配置文件/工具类/线程池/缓存/日志对象等

Design Pattern

单例模式只有一个实例 饿汉模式 私有构造方法 初始化实例private static 获取实例方法public static 加载类时创建实例 所以慢 线程安全 懒汉模式 私有构造方法 声明实例private static 获取实例方法public static里判断实例是否为空 空初始化实例 不空返回实例 加载类时只声明实例 所以快 用户获取实例时判断是否为空 为空初始化实例 否则返回实例 线程不安全

Gh

1.设计模式：是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 2.单例模式： 2.1应用场景：有些对象我们只需要一个，eg：皇帝、老婆 2.2作用：保证整个应用中某个实例有且只有一个 2.3类型以及实现 2.3.1饿汉模式 ①构造方法私有化，private，不允许外部直接创建对象 ②创建类的唯一实例，使用private static修饰，类加载时就创建了，所以加载速度较慢。 ③提供一个用于获取实例的使用public static修饰的方法，直接返回该实例，所以运行时获取对象的速度比较快。 2.3.2懒汉模式 ①同饿汉 ②声明类的实例，使用private static修饰，但不对其进行实例化，类加载时不进行创建 ③同饿汉，但是会在首次调用该方法时实例化声明的类的实例，在之后的调用中返回该实例化对象。 3.区别 饿汉模式 加载类的速度较慢，运行时获取对象的速度较快，同时是线程安全的 懒汉模式 加载类的速度较快，运行时第一次获取对象的速度较慢，线程不安全，需要加锁?