• 设计模式——单例模式
  

一、介绍    

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

    设计模式有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不是同一个实例");
       }
   }

 三、区别

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

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

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

Design Pattern

设计模式目的

使用设计模式的为了可重用代码、让代码更容易被他人理解、保证代码可靠性

设计模式：是一套被反复使用、所属人知晓的、经过分类编目的、代码设计经验的总结

设计模式：懒汉模式、饿汉模式

目的：可重用代码、易理解、保证代码可靠性

单例模式使用：在有些对象我们只需要一个的时候，比如：配置文件、工具类、线程池、缓存、日志对象等。如果创造多个实例，就会导致许多问题，比如占用过多资源，不一致的结果等。

设计模式：一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 目的：可重用代码，让代码更容易被他人理解、保证代码可靠性。 单例模式： 有些对象只需要一个，如：配置文件、工具类、线程池、缓存、日志对象等 多个程序读取一个配置文件，实际上配置文件还是只有一个，如果创造出多个实例，就会导致很多问题，占用资源过多，不一致的结果等 Java中的设计模式：23种 创建型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式； 结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式； 行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式； 其它：并发型模式和线程池模式；

设计模式--单例模式

如果创造出多个实例,机会导致许多问题,比如占用过多资源、不一致结果等

保证整个应用中某个实例有且只有一个

设计模式--单例模式

目的

@设计模式---单例模式(饿汉模式与懒汉模式)
单例模式：有些对象我们只需要一个，如：配置文件、工具类、线程池、缓存、日志对象等。

一、饿汉模式
    1. 将构造方法私有化，不允许外部直接访问。
    private Singleton(){}
    2. 创建 类的唯一实例, 使用private static修饰。
     private static Singleton  instance=new Singleton();
    3.提供一个用于获取实例的方法, 使用public static修饰。
    public static Singleton getInstance(){
        return instance;
    }
二、懒汉模式
    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;
    }
三、饿汉模式与懒汉模式的区别
    饿汉模式：加载类时比较慢，但运行时获取对象的速度比较快，线程安全
    懒汉模式：加载类时比较快，但运行时获取对象的速度比较慢，线程不安全

有且只有一个

设计模式的概念和目的