• 单例模式
  • 饿汉式
  • 懒汉式
  • 双重检测锁式
  • 静态内部类式(也是一种懒加载方式)
  • 枚举单例
• 工厂方法模式
  • 简单工厂模式
  • 工厂方法模式
• 原型模式
• 创建型模式总结

单例模式

• 核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
• 优点：
  • 一个单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
  • 单例模式可以在系统设置全局的访问点，优化环境共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理
• 常见的五中单例模式的实现方式：
  • 饿汉式（线程安全，调用效率高。但是，不能延时加载）
  • 懒汉式（线程安全，调用效率不高。但是，可以延时加载）
  • 双重检测锁式（由于 JVM 底层内部模型的原因。不建议使用）
  • 静态内部类式（线程安全，调用效率高。但是，可以延时加载）
  • 枚举单例（线程安全，调用效率高，不能延时加载，避免反射和反序列化的漏洞）
• 如何选择
  • 单例对象，占用资源少，不需要延时加载
    • 枚举式好于饿汉式
  • 单例对象，占用资源大，需要延时加载
    • 静态内部类好于懒汉式

饿汉式

• 饿汉式单例模式代码中，static 变量会在类装载时初始化，此时也不会设计多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略 synchronized 关键字
• 问题：如果只是加载本类，而不是要调用 getInstance()，甚至永远没有调用，则会造成资源浪费！

public class SingletonDemo01 {
    /**
     * 类初始化时，立即加载这个对象！
     * 加载类时，天然线程安全！
     * */
    private static SingletonDemo01 instance = new SingletonDemo01();

    private SingletonDemo01() {
    }
    /**
     * 方法没有同步，效率调用高
     * */
    public static SingletonDemo01 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        SingletonDemo01 s1= SingletonDemo01.getInstance();
        SingletonDemo01 s2 = SingletonDemo01.getInstance();
        System.out.println(s1==s2);//true
    }
}

懒汉式

• 要点：lazy load！延迟加载，懒加载！真正用的时候才加载！
• 问题：资源利用率高了。但是，每次调用 getInstance() 方法都要同步，并发效率较低。

public class SingletonDemo02 {
    /**
     * 类初始化时，不初始化这个对象（延时加载，真正要用的时候在创建）
     * */
    private static SingletonDemo02 s;

    private SingletonDemo02(){}
    /**
     * 方法同步，调用效率第
     * */
    public static synchronized SingletonDemo02 getInstance() {
        if (s == null) {
            s = new SingletonDemo02();
        }
        return s;
    }
}

双重检测锁式

• 这个模式将同步内容下放到 if 内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
• 问题：由于编译器优化原因和 JVM 底层内部模型的原因，偶尔会出问题，不建议使用。

public class SingletonDemo03 {
    private static SingletonDemo03 instance = null;
    public static SingletonDemo03 getInstance() { if (instance == null) {
        SingletonDemo03 sc;
        synchronized (SingletonDemo03.class) {
            sc = instance; if (sc == null) {
                synchronized (SingletonDemo03.class) {
                    if(sc == null) {
                        sc = new SingletonDemo03(); }
                }
                instance = sc;
            } }
    }
        return instance; }
    private SingletonDemo03() {
    }
}

静态内部类式(也是一种懒加载方式)

• 外部类没有static属性，则不会像饿汉式那样立即加载对象。
• 只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。 instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性.
• 兼备了并发高效调用和延迟加载的优势!

public class SingletonDemo04 {
    private static class SingletonClassInstance {
        private static final SingletonDemo04 INSTANCE = new SingletonDemo04();
    }
    public static SingletonDemo04 getInstance() {
        return SingletonClassInstance.INSTANCE;
    }

    private SingletonDemo04() {
    }
}

枚举单例

• 优点:
  • 实现简单
  • 枚举本身就是单例模式。由JVM从根本上提供保障!避免通过反射和反序列化的漏洞!
• 缺点:无延迟加载

public enum SingletonDemo05 {
    /**
    * 定义一个枚举的元素，它就代表了Singleton的一个实例。
    */
    INSTANCE;
    /**
    * 单例可以有自己的操作
    */
    public void singletonOperation(){
    //功能处理
    }
}

工厂方法模式

• 实现了创建者和调用者的分离
• 详细分类：
  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式
• 面向对象设计的基本原则
  • OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。
  • DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。
  • LOD（迪米特原则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。
• 核心本质：
  • 实例化对象，用工厂方法代替 new 操作
  • 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
• 常见工厂模式
  • 简单工厂模式
    • 用来生产同一等级结构中的任意产品。(对于增加新的产品，需要修改已有代码)
  • 工厂方法模式
    • 用来生产同一等级结构中的固定产品。(支持增加任意产品)
  • 抽象工厂模式
    • 用来生产不同产品族的全部产品。(对于增加新的产品，无能为力;支持增加产品族)

简单工厂模式

• 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数不同来返回不同的对象实例。
• 对于增加新产品无能为力！不修改代码无法扩展

public class CarFactory {
    public static Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){ 
            return new Byd();
        }
        return null;
    }
}

public class CarFactory02 {
    public static Car createAudi(){
        return new Audi();
    } 
    public static Car createByd(){
        return new Byd();
    }
}

工厂方法模式

• 为了避免简单工厂模式的缺点，不完全满足OCP。
• 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个(对于一个项目 或者一个独立模块而言)工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

• 根据设计理论建议:工厂方法模式。但实际上，我们一般都用简单工厂模式。

抽象工厂模式

• 用来生产不用产品族的全部产品（对于增加新的产品，无能为力；支持增加产品族）
• 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方案

建造者模式

• 使用场景
  • 需要建造一个复杂的产品。比如；神州飞船，Iphone。这个复杂的产品的创建，有这样一个问题需要处理：
    • 装配这些子组件是不是有个步骤问题
  • 实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理
• 建造模式的本质：
  • 分离了对象子组件的单独构造（由 Builder 来负责）和装配（由 Director 负责）。从而可以构造出复杂的对象，这个模式适用于：某个对象的构建过程复杂的情况下使用。
  • 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象; 相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配 算法的解耦，实现了更好的复用。
• 开发中应用场景
  • StringBuilder 类的 append 方法
  • SQL 中的 PreparedStatement
  • JDOM、DomBuilder、SAXBuilder
    

原型模式

• 使用场景:
  • 思考一下:克隆技术是怎么样的过程? 克隆羊多利大家还记得吗?
  • javascript语言中的，继承怎么实现?那里面也有prototype，大家还记得吗?
• 原型模式:
  • 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
  • 就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点
  • 优势有:效率高(直接克隆，避免了重新执行构造过程步骤) 。
  • 克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的 对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后， 再修改克隆对象的值。
• 原型模式实现:
  • Cloneable接口和clone方法
  • Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了 clone()方法替我们做了绝大部分事情。

创建型模式总结

• 都是用来帮助我们创建对象的!
  • 单例模式
    • 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
  • 工厂模式
    • 简单工厂模式
      • 用来生产同一等级结构中的任意产品。(对于增加新的产品，需要修改已有代码)
    • 工厂方法模式
      • 用来生产同一等级结构中的固定产品。(支持增加任意产品)
    • 抽象工厂模式
      • 用来生产不同产品族的全部产品。(对于增加新的产品，无能为力;支持增加产品族)
  • 建造者模式
    • 分离了对象子组件的单独构造(由Builder来负责)和装配(由Director负责)。从而可 以构造出复杂的对象。
  • 原型模式
    • 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式