【设计模式】23种设计模式之创建型模式

gitee源代码：https://gitee.com/zhao_liangliang1997/untitled2023/tree/master/src

一、单例模式

1、是什么？

采取一定的方法保证在整个的软件系统中，对于某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)

2、单例模式有哪八种方式？

1）、饿汉式（静态常量）
2）、饿汉式（静态代码块）
3）、懒汉式（线程不安全）
4）、懒汉式（线程安全，同步方法）
5）、懒汉式（线程安全，同步代码块）
6）、双重检查
7）、静态内部类
8）、枚举

3、饿汉式（静态常量）【可用，可能会造成内存浪费】

public class Singleton01 {
    /**
     *  1、构造器私有化
     *  2、类的内部创建对象
     *  3、向外暴露一个静态的公共方法
     **/
    public static void main(String[] args) {
        Singleton test = Singleton.getInstance();
    }
}
class Singleton {
    // 1、构造器私有化 防止外部new
    private Singleton(){}

    // 2、本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    // 3、提供一个公有的静态方法 返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

优点： 写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题；
缺点： 在类装载的时候就完成实例化，没有达到懒加载的效果，若不使用则会造成内存的浪费；

4、饿汉式（静态代码块）【可用，可能会造成内存浪费】

与第一种方式类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

5、懒汉式（线程不安全）【实际开发，不要使用这种方式】

1、起到了懒加载的效果，但是只能在单线程下使用；
2、如果在多线程下，一个线程进入判断语句，还未执行另一个线程也通过了这个判断语句，便会产生多个实例。

6、懒汉式（线程安全，同步方法）【实际开发，不推荐使用】

1、解决了线程安全问题；
2、效率太低了，每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该实例，直接return。方法进行同步效果太低。

7、懒汉式（线程安全，同步代码块）【不推荐使用】

8、双重检查【推荐使用】

1、双重检查概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if检查，这样就可以保证线程安全了；
2、这样，实例化代码只用执行一次，后面再次访问时，判断直接return实例化对象，也避免反复进行方法同步；
3、线程安全；延迟加载；效率较高；

9、静态内部类【推荐使用】

1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程；
2、静态内部类方法在Singleton类被装载的时候不会立即实例化，而是在需要实例化的时，调用getInstance，才会装载SingletonInstance类，从而完成Singleton的实例化。
3、类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4、优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

class Singleton {
    // 1、构造器私有化 防止外部new
    private Singleton(){}
    // 2、本类内部创建对象实例
    private static Singleton instance;
    // 3、写一个静态内部类 该类中有一个静态属性 Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
    // 4、提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

10、静态内部类【推荐使用】

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

public class Singleton08 {
    public static void main(String[] args) {
        Singleton test = Singleton.INSTANCE;
        Singleton test2 = Singleton.INSTANCE;
        test.sayOK();
    }
}
// 使用枚举,可以实现单例 【推荐】
enum Singleton {
    INSTANCE;//属性
    public void sayOK(){
        System.out.println("ok~");
    }
}

11、单例模式注意事项和细节说明

1、单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；

2、当想实例化一个单例类的时候，必须要记住使用相对应的对象的方法，而不是使用new；

3、单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如数据域、session工厂等）；

二、工厂方法模式

2.1简单工厂模式

1、定义：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
2、设计方案：定义一个可以实例化Pizza对象的类，封装创建对象的代码。

思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改这类就可。其它有创建到Pizza对象的代码就不需要修改了---->简单工厂模式

2.2工厂方法模式

定义： 定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

三、抽象工厂模式

1、定义：定义一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
2、抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3、从设计层面看，抽象工厂模式就是对简单工厂模式的改进。
4、将工厂抽象成两层，AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

四、工厂模式小结

4.1工厂模式的意义

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

4.2三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）

4.3设计模式的依赖抽象原则

1、抽象对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中并返回。有的书上说，变量不要直接持有具体类的作用。
2、不要让类继承具体类，而是继承抽象类或者是实现interface接口
3、不要覆盖基类中已经实现的方法。

五、原型模式

5.1 传统方式解决克隆羊问题

传统的方式的优缺点：

（1）优点是比较好理解，简单易操作。
（2）在创建新的对象时，总是需要获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
（3）总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活
（4）改进的思路分析。

5.2 使用默认的clone方法

改进思路：
java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个java对复制一份，但是需要实现clone的java类必须实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力===>>> 原型模式

5.2 原型模式的注意事项和细节

（1）创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
（2）不用重新初始化对象，而是动态地获得对象运行时的状态。
（3）如果原始对象发生变化【增加或者减少属性】，其它克隆对象的也会发生相应的编号，无需修改代码。
（4）在实现深克隆的时候可能需要比较复杂的代码。
（5）缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了开闭原则【OCP】。

六、建造者模式

6.1盖房子需求—传统解决方案

6.2传统方式的问题分析

1、优点是比较好理解，简单易操作；
2、设计的程序结构，过于简单，没有设计缓存层对象，程序的扩展和维护不好。把“产品”、“创建产品的过程”封装在一起，耦合性增强了。
3、解决方案----->将产品和产品建造过程解耦==>建造者模式

6.3建造者模式基本介绍

1）、建造者模式(Builder Patern) 又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别) ，使这个抽象过程的不同实现方法可以构造出不同表现(属性) 的对象。
2）、建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，2用户不需要知道内部的具体构建细节。

6.4建造者模式的四个角色

1）Product(产品角色) : 一个具体的产品对象
2）Builder(抽象建造者) : 创建一个 Product 对象的各个部件指定的 接口/抽象类
3）ConcreteBuilder (具体建造者) : 实现接口，构建和装配各个部件。
4）Director(指挥者): 构建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是:隔离了客户与对象的生产过程，二是:负责控制产品对象的生产过程。

6.5使用建造者模式实现–盖房子需求

6.6建造者模式的注意事项和细节

参考文章：https://blog.csdn.net/Youth_lql/article/details/118448829