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

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

    • 一、单例模式
      • 1、是什么?
      • 2、单例模式有哪八种方式?
      • 3、饿汉式(静态常量)【可用,可能会造成内存浪费】
      • 4、饿汉式(静态代码块)【可用,可能会造成内存浪费】
      • 5、懒汉式(线程不安全)【实际开发,不要使用这种方式】
      • 6、懒汉式(线程安全,同步方法)【实际开发,不推荐使用】
      • 7、懒汉式(线程安全,同步代码块)【不推荐使用】
      • 8、双重检查【推荐使用】
      • 9、静态内部类【推荐使用】
      • 10、静态内部类【推荐使用】
      • 11、单例模式注意事项和细节说明
    • 二、工厂方法模式
      • 2.1简单工厂模式
      • 2.2工厂方法模式
    • 三、抽象工厂模式
    • 四、工厂模式小结
      • 4.1工厂模式的意义
      • 4.2三种工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)
      • 4.3设计模式的依赖抽象原则
    • 五、原型模式
      • 5.1 传统方式解决克隆羊问题
      • 5.2 使用默认的clone方法
      • 5.2 原型模式的注意事项和细节
    • 六、建造者模式
      • 6.1盖房子需求---传统解决方案
      • 6.2传统方式的问题分析
      • 6.3建造者模式基本介绍
      • 6.4建造者模式的四个角色
      • 6.5使用建造者模式实现--盖房子需求
      • 6.6建造者模式的注意事项和细节

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、饿汉式(静态代码块)【可用,可能会造成内存浪费】

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

【设计模式】23种设计模式之创建型模式_第1张图片

5、懒汉式(线程不安全)【实际开发,不要使用这种方式】

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

【设计模式】23种设计模式之创建型模式_第2张图片

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

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

【设计模式】23种设计模式之创建型模式_第3张图片

7、懒汉式(线程安全,同步代码块)【不推荐使用】

【设计模式】23种设计模式之创建型模式_第4张图片

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

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

【设计模式】23种设计模式之创建型模式_第5张图片

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对象的类,封装创建对象的代码。

【设计模式】23种设计模式之创建型模式_第6张图片

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

【设计模式】23种设计模式之创建型模式_第7张图片

2.2工厂方法模式

定义: 定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类
【设计模式】23种设计模式之创建型模式_第8张图片

三、抽象工厂模式

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

四、工厂模式小结

4.1工厂模式的意义

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

4.2三种工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)

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

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

五、原型模式

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

传统的方式的优缺点:

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

【设计模式】23种设计模式之创建型模式_第10张图片

5.2 使用默认的clone方法

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

【设计模式】23种设计模式之创建型模式_第11张图片

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

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

六、建造者模式

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

【设计模式】23种设计模式之创建型模式_第12张图片

6.2传统方式的问题分析

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

6.3建造者模式基本介绍

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

6.4建造者模式的四个角色

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

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

【设计模式】23种设计模式之创建型模式_第13张图片

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

【设计模式】23种设计模式之创建型模式_第14张图片
【设计模式】23种设计模式之创建型模式_第15张图片
参考文章:https://blog.csdn.net/Youth_lql/article/details/118448829
在这里插入图片描述

你可能感兴趣的:(设计模式,设计模式,单例模式,java)