设计模式创建型模式知识点小结

我就是我 2022-08-04 15:57 159阅读 0赞

【摘要】

按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。创建型模式包括工厂方法模式（Factory Method Pattern）、抽象工厂模式(Abstract Factory Pattern） 、建造者模式（Builder Pattern）、原型模式（Prototype Pattern）单例模式（Singleton Pattern）。本文将详述创建型各个模式的定义、实现案例并分析比较各模型之间的共性和区别。

<table style="text-align:left"> 
 <tbody> 
 <tr> 
 <td colspan="2" style="background:rgb(153,204,255)"> 设计模式分类 </td> 
 <td style="background:rgb(153,204,255)"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(204,255,255)"> 创建型模式 </td> 
 <td> <a href="http://blog.csdn.net/rexuefengye/article/details/12704821" rel="nofollow">工厂方法模式</a> （Factory&nbsp;Method&nbsp;Pattern） </td> 
 <td> 定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。 </td> 
 </tr> 
 <tr> 
 <td> <a href="http://blog.csdn.net/rexuefengye/article/details/12706593" rel="nofollow">抽象工厂模式</a> (Abstract&nbsp;Factory&nbsp;Pattern） </td> 
 <td> 提供一个创建一系列相关或者相互依赖的接口，而无需指定它们具体的类。 </td> 
 </tr> 
 <tr> 
 <td> <a href="http://blog.csdn.net/rexuefengye/article/details/12780555" rel="nofollow">建造者模式</a> （Builder&nbsp;Pattern） </td> 
 <td> 将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 </td> 
 </tr> 
 <tr> 
 <td> <a href="http://blog.csdn.net/rexuefengye/article/details/12783895" rel="nofollow">原型模式</a> （Prototype&nbsp;Pattern） </td> 
 <td> 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 </td> 
 </tr> 
 <tr> 
 <td> <a href="http://blog.csdn.net/rexuefengye/article/details/12709989" rel="nofollow">单例模式</a> （Singleton&nbsp;Pattern） </td> 
 <td> 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 </td> 
 </tr> 
 </tbody> 
</table>

【正文】

*  工厂模式  
    
    
    **定义**

> Factory模式不单单提供对象的接口，更重要的是延迟了子类实例化，将对象的创建放到了子类之中。

> **示例**

> 基本类
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类（产品接口） </td> 
> <td colspan="3"> 人 </td> 
> </tr> 
> <tr> 
> <td> 派生类（产品） </td> 
> <td> 黄种人 </td> 
> <td> 黑种人 </td> 
> <td> 白种人 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 工厂类
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类（工厂接口） </td> 
> <td colspan="3"> 返回创建 &nbsp;人 的类方法 </td> 
> </tr> 
> <tr> 
> <td> 派生类（工厂） </td> 
> <td> 返回创建&nbsp;黄&nbsp;的方法 </td> 
> <td> 返回创建&nbsp;黑&nbsp;的方法 </td> 
> <td> 返回创建&nbsp;白&nbsp;的方法 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 主函数.cpp
> 
> <table> 
> <tbody> 
> <tr> 
> <td colspan="2"> main.cpp </td> 
> </tr> 
> <tr> 
> <td> 自定义函数【3个】 </td> 
> <td> 创建各种&nbsp;人&nbsp;的类的实例化 </td> 
> </tr> 
> <tr> 
> <td> 主函数 </td> 
> <td> 调用自定义函数 </td> 
> </tr> 
> </tbody> 
> </table>

小结：工厂模式的特点就是把对象的“构造函数”封装起来，创建“构造函数”类和“构造函数”派生类系列。

*  抽象工厂模式

> **定义**
> 
> Abstract Factory模式更注重接口的组合，即，将一组对象的创建封装到一个用于创建对象的类中，维护这样一个创建接口要比创建几个简单对象简单得多。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。对于工厂方法来说，抽象工厂可实现一系列产品的生产，抽象工厂更注重产品的组合。

> **示例**
> 
> 基本类
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类（产品接口） </td> 
> <td colspan="6"> 人 </td> 
> </tr> 
> <tr> 
> <td> 派生类1（抽象产品） </td> 
> <td colspan="2"> 黄种人 </td> 
> <td colspan="2"> 黑种人 </td> 
> <td colspan="2"> 白种人 </td> 
> </tr> 
> <tr> 
> <td> 派生类2（具体产品） </td> 
> <td> 黄种男人 </td> 
> <td> 黄种女人 </td> 
> <td> 黑种男人 </td> 
> <td> 黑种女人 </td> 
> <td> 白种男人 </td> 
> <td> 白种女人 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 抽象工厂类
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类（抽象工厂） </td> 
> <td colspan="2"> 返回创建&nbsp;黄+黑+白&nbsp;人&nbsp;的类方法 </td> 
> </tr> 
> <tr> 
> <td> 派生类（工厂） </td> 
> <td> 返回创建&nbsp;男*3&nbsp;的方法 </td> 
> <td> 返回创建&nbsp;女*3&nbsp;的方法 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 主函数.cpp
> 
> <table> 
> <tbody> 
> <tr> 
> <td colspan="2"> main.cpp </td> 
> </tr> 
> <tr> 
> <td> 自定义函数【6】 </td> 
> <td> 创建各种&nbsp;人&nbsp;的类的实例化 </td> 
> </tr> 
> <tr> 
> <td> 主函数 </td> 
> <td> 调用自定义函数 </td> 
> </tr> 
> </tbody> 
> </table>

**小结：抽象工厂模式的特点就是把多个同辈对象的“构造函数”封装起来，每一个“构造函数”返回一个类。虽然，抽象工厂模型与工厂模型相类似，但是，抽象工厂模式针对的类结构较工厂模式更为复杂，即，层次更多。此外，抽象工厂针对的是具体产品类的父类的创建**的**，这里不再顾及产品接口类（祖辈）。**

*  单例模式

> Singleton 模式在系统中只允许产生这个类的一个实例。Singleton 模式解决问题十分常见，即我们怎样去创建一个唯一的变量(一个类只能产生一个对象)。在基于对象的设计中我们可以通过创建一个全局变量(对象)来实现，在面向对象和面向过程结合的设计范式(如 C++中)中，我们也还是可以通过一个全局变量实现这一点。但是，当我们遇到了纯粹的面向对象范式中，这一点可能就只能是通过 Singleton 模式来实现了。 Singleton 模式是设计模式中最为简单、最为常见、最容易实现，在 Singleton 模式的结构图中可以看到，我们通过维护一个 static 的成员变量来记录这个唯一的对象实例。通过提供一个staitc 的接口instance 来获得这个唯一的实例。 
> 
> 注意：线程安全，采用互斥体的方式实现。  
>

**小结：抽单例模式****定义一个静态指针，和一个静态函数，私有化构造函数、析构函数、构造函数复制、重载赋值语句**。

*  建造者模式

> **定义**

> Builder模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。实现创建不同表示的方法就是给创建的过程传入创建的参数。Builder 模式的关键是其中的 Director 对象并不直接返回对象,而是通过一步步(Build PartA -> Build PartB -> Build PartC)来一步步进行对象的创建。当然这里Director可以提供一个默认的返回对象的接口(即返回通用的复杂对象的创建,即不指定或者特定唯一指定BuildPart中的参数)。 建造者模式和抽象工厂非常类似。建造者更重视产品建造时的逻辑顺序，而抽象工厂更重视生产出不同型号的产品，抽象工厂不关心顺序。

> **示例**
> 
> 基本类
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类 （产品模型） </td> 
> <td colspan="2"> 汽车模型（需要调用输出不同字符串的各个函数，字符串输出函数的调用顺序因调用Run函数输入参数的不同而变化） </td> 
> </tr> 
> <tr> 
> <td> 派生类（产品） </td> 
> <td> 宝马模型（自定义字符串输出函数） </td> 
> <td> 奔驰模型（自定义字符串输出函数） </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 建造者类定义
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 父类（建造者接口接口） </td> 
> <td colspan="2"> 返回创建 汽车模型 的类方法 和 参数设置函数 </td> 
> </tr> 
> <tr> 
> <td> 派生类（建造者） </td> 
> <td> 设置宝马参数 返回宝马模型 </td> 
> <td> 设置奔驰参数 返回奔驰模型 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> Director 类（通过dynamic\_cast转换类对象指针）
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 成员变量 </td> 
> <td> 不同参数 </td> 
> </tr> 
> <tr> 
> <td> 成员函数 </td> 
> <td> 返回不同参数设置的模型 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 主函数.cpp
> 
> <table> 
> <tbody> 
> <tr> 
> <td colspan="2"> main.cpp </td> 
> </tr> 
> <tr> 
> <td> 自定义Run函数 </td> 
> <td> 设计字符串 实例化汽车模型（一次只能实现一个模型单例） </td> 
> </tr> 
> <tr> 
> <td> 自定义Build函数 </td> 
> <td> 通过Build类实现汽车实例化（一次能实现一个模型类别） </td> 
> </tr> 
> <tr> 
> <td> 自定义Director函数 </td> 
> <td> 通过Director类实现汽车实例化（一次能实现全部类别） </td> 
> </tr> 
> <tr> 
> <td> 主函数 </td> 
> <td> 调用自定义函数 </td> 
> </tr> 
> </tbody> 
> </table>

**小结：建造者模式关注建造的顺序，这个类需要哪些参数，****这些参数怎样一步一步构建得到类实体。步进参数作为成员变量，祖类接口作为 Director 返回数据类型，两者构成了建造者模式的核心。**

*  原型模式

> **定义**
> 
> Prototype 模式提供了自我复制的功能，就是说新对象的创建可以通过已有对象进行创建。在 C++中拷贝构造函数(Copy Constructor)中浅层拷贝和深层拷贝与本例有相似之处。 Prototype 模式提供了一个通过已存在对象进行新对象创建的接口(Clone)。这个模式的简单程度是仅次于单例模式和迭代器模式，非常简单，但是要使用好这个模式还有很多注意事项。
> 
> **示例**
> 
> 基本类定义
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 广告模板 </td> 
> <td> 广告主题字符串+广告主体字符串 </td> 
> </tr> 
> <tr> 
> <td> 邮件 （原型模式） </td> 
> <td> 成员变量&nbsp;：发件人+收件人+主体+主题 </td> 
> </tr> 
> <tr> 
> <td> 成员函数&nbsp;：广告克隆函数 </td> 
> </tr> 
> </tbody> 
> </table>
> 
> 主函数.cpp
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 自定义函数（发邮件） </td> 
> <td> 模板对象&nbsp;-&gt;&nbsp;邮件对象&nbsp;-&gt;&nbsp;邮件参数设置 </td> 
> </tr> 
> <tr> 
> <td> 主函数 </td> 
> <td> 循环发送邮件 </td> 
> </tr> 
> </tbody> 
> </table>

**小结：原型模式主要在于类对象拷贝函数的实现。实质就是返回类对象“模板”。**