【设计模式】学习笔记--单例模式（饿汉式、懒汉式、双重检查、静态内部类）

1. 单例模式

1. 饿汉式（静态Static）

1. 步骤：①构造器私有化 ②内部构造一个对象实例 ③提供一个公共的静态方法

// 饿汉式
public class SingleTon {
    // 1. 构造器私有化
    private SingleTon(){}
    // 2. 内部创造一个对象实例类
    private final static SingleTon instance = new SingleTon();
    //  3. 提供一个公有静态方法
    public static  SingleTon getInstance() {
        return instance;
    }
}

2. 优点：简单，在类装载前完成实例化，避免了线程同步问题（因为静态变量在程序开始运行时就会执行，并且只执行一次）

   缺点：不能达到懒加载（lazy loading）效果，不使用的情况下会造成内存浪费。

2. 懒汉式（不推荐）

1. 与饿汉式不同，只有用到类时，才会实例化对象。

//懒汉式
public  class SingleTon_lHan {
    // 构造器私有化
    private SingleTon_lHan(){}
    // 内部创造一个对象实例类
    private static SingleTon_lHan instance;
    //  synchronized 加入同步处理，解决线程安全问题
    public static synchronized SingleTon_lHan getInstance() {
        // 没有的情况下再赋值  
        if(instance == null){
            instance = new SingleTon_lHan();
        }
        return instance;
    }
}

2. 优点：线程安全，也有懒加载

   缺点：效率低，每个线程都要实例化，同时存在线程安全问题（因为再给线程赋值之前可能有另一个也会进入赋值步骤）

3. 双重检查（推荐使用）

1. 利用双重检查保证只有一个线程可以实例化类

   // 双重检查
   public class SigeleTon_DoubleCheck {
       // 构造函数
       private SigeleTon_DoubleCheck(){}
       // 申明参数
       private static SigeleTon_DoubleCheck instance;
       // 外部调用函数
       public static SigeleTon_DoubleCheck getInstance(){
           // 第一层保护 保证单线程
           if (instance == null){
               synchronized (SigeleTon_DoubleCheck.class){
                   // 第二层保护  确保只有一个线程赋值成功  阻止第二个线程进入
                   if (instance == null) {
                       instance = new SigeleTon_DoubleCheck();
                   }
               }
           }
           return instance;
       }
   }

4. 静态内部类（推荐使用）

// 静态内部类
public class SingleTon_StaticClass {
    // 构造函数
    private SingleTon_StaticClass(){}
    // 内部静态类
    private static class singleton{
        // 在类中实例化
        private static final SingleTon_StaticClass instance = new SingleTon_StaticClass();
    }
    // 外部调用类  实现懒加载 并且线程安全
    public static synchronized SingleTon_StaticClass getInstance(){
        return singleton.instance;
    } 
}

2. 工厂模式（9.11 更新）

1. 简单工厂模式（静态）

1. 定义：将操作放入一个工厂中进行操作，由一个工厂对象来决定创造出哪一种产品实例。定义了一个创建对象的类，由这个类来封装实例化对象的行为。（披萨订购，由工厂类决定输出）

2. 优点：比较好理解，简单易操作

   缺点：违反设计模式的ocp原则，即对扩展开发，对修改关闭，如果需要新增功能，会修改代码。

2. 工厂方法模式（抽象）

1. 设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同口味点餐中具体实现。即由子类去定义各自的方法。

2. 定义：定义了一个创建对象的抽象方法，有子类据欸的那个要实例化的类。工厂方法模式将对象的实例化推迟到子类。

3. 抽象工厂模式 (接口) JDK-Calendar

1. 定义了一个接口用于创建相关或有意依赖关系的对象，不需要指明具体的类。
2. 可以看作简单工厂模式与工厂方法模式的结合。

4. 意义

将实例化对象的代码提取出来，放到一个类中维护，达到和主项目的依赖关系解耦，从而提高项目的 扩展性与维护性。