设计模式 创建者模式

2023-12-02 17:30
文章标签 设计模式 模式 创建者

本文主要是介绍设计模式 创建者模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

设计模式 创建者模式

  • 前言
  • 原来代码
  • 使用设计模式
  • 总结
  • Builder模式在源码中的应用：
  • 其他代码

前言

  1. “对象创建”模式——绕开new

    工厂模式 抽象工厂 原型模式 构建器

  2. 动机与背景

    目前需要建造一个房子，建造房子需要一系列特定的步骤，但是房子的类型也有很多，不同类型的房子对应的建造步骤也不尽相同。
    用于分步骤构建对象

  3. 没有使用设计模式的代码

// 可以参照模板方法

  1. 存在的问题

    个人感觉与模板方式很相似，所以上面的代码使用了模板方法的代码

  2. 解决方法

    使用构建器，将复杂多变的对象的构建过程抽象出来

  3. 使用设计模式的代码

原来代码

Builder 模式主要用于“分步骤构建一个复杂的对象”。
在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。
其缺点在于难以应对“分步骤构建算法”的需求变动。在Builder模式中，要注意不同语言中构造器内调用虚函数的差别（C++ vs. C#) 。

//原来的代码
class House{protected:void init(){ //1.构建的流程是稳定的this -> BuildPart1(); // 打地基for(int i  = 0 ; i < 4 ; i ++){this -> BuildPart2();}bool flag = this -> BuildPart3();if(flag){this -> BuildPart4();			}this -> BuildPart5();	}virtual ~House(){}//代表建房子的门 窗户 等 ，2.构建的方法是变化的，纯虚函数virtual void BuildPart1() = 0;virtual void BuildPart2() = 0;virtual void BuildPart3() = 0;virtual void BuildPart4() = 0;virtual void BuildPart5() = 0;}；

在这里有个问题是，能不能把init函数名替换成构造函数：不能，C++构造函数是静态绑定

class StoneHose：public House{protected: //实例化virtual void BuildPart1(){...............}virtual void BuildPart2(){...............}virtual void BuildPart3(){...............}virtual void BuildPart4(){...............}virtual void BuildPart5(){...............}
}；

到这里已经完成了，使用：

int main()
{//就是父类指针指向子类对象House * pHouse = new StoneHose();pHouse ->Init();}

使用设计模式

//把上面的代码，用设计模式
//如果对象比较复杂，可以做如下拆分，把House分成两个，一个是定义方法（可变）的叫做HouseBuilder ,一个定义流程、逻辑的是把init放进去

class House{//........void Part1();void Part2();void Part3();}；class HouseBuilder{public:House *GetResult() {return pHouse;}	virtual ~HouseBuilder(){}protected://代表建房子的门 窗户 等 ，2.构建的方法是变化的，纯虚函数virtual void BuildPart1() = 0;virtual void BuildPart2() = 0;virtual void BuildPart3() = 0;virtual void BuildPart4() = 0;virtual void BuildPart5() = 0;};

//塞一个 HouseBulider指针,把 this 换成pHouseBuilder

class HouseDirector{public:HouseBulider *pHouseBuilder;//另外要加入构造函数HouseDirector(HouseBulider *pH){  //新加入this -> pHouseBuilder = pH;}HouseBulider Construct(){//void init()  构建过程,不是虚函数pHouseBuilder -> BuildPart1(); // 打地基for(int i  = 0 ; i < 4 ; i ++){pHouseBuilder -> BuildPart2();//把init()中的 this 换成pHouseBuilder}bool flag = pHouseBuilder -> BuildPart3();if(flag){pHouseBuilder -> BuildPart4();			}pHouseBuilder -> BuildPart5();	return pHouseBuilder->GetResult();}
}

//那么石头房子呢 StoneHose：public House 感觉这里是不需要呀 看这个https://zhuanlan.zhihu.com/p/665141864

class StoneHose：public House{  //对象的表示}；class StoneHoseBuilder：public HouseBuilder{ //  实现protected:  virtual void BuildPart1(){...............}virtual void BuildPart2(){...............}virtual void BuildPart3(){...............}virtual void BuildPart4(){...............}virtual void BuildPart5(){...............}
}；

void main() {StoneHouseBuilder *pStoneHouseBuilder = new StoneHouseBuilder;HouseDirector *pHouseDirector = new HouseDirector(HouseBuilder *pStoneHouseBuilder);pHouseDirector->Construct();// 操作
}

构建过程太复杂，抽象出来单独变成类
把对象的表示和构建相分离，（House 和 HouseBuilder），是的同样的构建(稳定)过程（Construct）可以构建不同的表示（变化）
上面只是一个演化模式，

总结

总结一下，就是把一个有构建步骤的对象拆分，分成表示和实现方法过程，实现过程稳定（不抽象），表示部分可以抽象，用虚函数实现

class A{//需要创建的事物、对象，这里定义A的组成
set_Part1();

}
class B_builer (方法接口){ //A的组成实现接口，要有能返回A的接口
//1.要拥有A指针成员 A *m_a
//2.要拥有构造函数，传入A，实现多态 B_builer(A a){this->m_a = a;}
//3.要有返回A 的方法接口 A GetComputer()
//4.要定义建造A需要的方法接口：buildPart1 2 3 4 …

A *m_a ；
B_builer(A *a){this->m_a = a;}
virtual buildPart1() = 0;
virtual A* GetComputer() = 0; // 要有返回A 的方法接口

}；
class B_concrete_builer (方法实现)：public B_builer{
virtual buildPart1(){ this -> A->setPart1();} //具体实现
virtual A* GetComputer(){return tbis->A ;}; // 具体实现 要有返回A 的方法接口
}；

class C_Process （稳定的构建过程）
{
//1.要拥有建造（材料）的方法接口的指针成员 B_builer *m_b_builer
B_builer *m_b_builer ；
//2.要拥有构造函数，传入B_builer，实现多态
C_Process(B_builer *b_builer){this->m_b_builer = b_builer;}
//2，稳定的构建过程代码（建造逻辑） ，要返回A
A *func(){
step 1 2 3 …
return m_b_builer->GetResult();
}

}

使用过程：
B_concrete_builer *B = new B_concrete_builer();
C_Process *C = new C_Process(B);
C->func()；
A = B->GetComputer();

Builder模式在源码中的应用：

StringBuilder

其实我们熟知的StringBuilder就是builder模式的典型实现。我们平时使用基本都是这样：

1 StringBuilder sb = new StringBuilder();
2 sb.append(123).append(‘a’)
3 .append(1.23)
4 .append(true)
5 .append(“hhhh”);

https://zhuanlan.zhihu.com/p/113971558

其他代码

这个很好：
https://zhuanlan.zhihu.com/p/665141864
//下面是源码

#include <iostream>
using namespace std;#include <string>//需要的产品：笔记本电脑
class Computer {
public:void SetCPU(const string cpu) {this->cpu = cpu;}void SetDisk(const string disk) {this->disk = disk;}void SetMemory(const string memory) {this->memory = memory;}void SetScreen(const string screen) {this->screen = screen;}void ShowInfo() {cout << "======基本信息======" << endl;cout << this->cpu << endl;cout << this->memory << endl;cout << this->disk << endl;cout << this->screen << endl;cout << "====================" << endl;}private:string cpu; //CPUstring disk; //磁盘string memory; //内存string screen; //显示屏
};//抽象的建造者：抽象建造单位
class Builder
{
public:virtual void BuilderCpu() = 0; //建造CPUvirtual void BuilderMemory() = 0; //建造内存virtual void BuilderDisk() = 0; //建造磁盘virtual void BuilderScreen() = 0; //建造显示屏virtual Computer* GetComputer() = 0; //出厂建造好的笔记本
};//具体的建造者：具体施工单位、具体的建造方式
class DellBuilder : public Builder //dell笔记本
{
private:Computer* computer;
public:DellBuilder() {this->computer = new Computer(); }void BuilderCpu() {this->computer->SetCPU("DELL CPU");}void BuilderMemory() {this->computer->SetMemory("DELL 内存");}void BuilderDisk() {this->computer->SetDisk("Dell 磁盘");}void BuilderScreen() {this->computer->SetScreen("DELL 显示屏");}Computer* GetComputer(){return this->computer;}};//具体的建造者：具体施工单位、具体的建造方式
class AppleBuilder : public Builder //dell笔记本
{private:Computer* computer;
public:AppleBuilder() {this->computer = new Computer(); }void BuilderCpu() {this->computer->SetCPU("Apple CPU");}void BuilderMemory() {this->computer->SetMemory("Apple 内存");}void BuilderDisk() {this->computer->SetDisk("Apple 磁盘");}void BuilderScreen() {this->computer->SetScreen("Apple 显示屏");}Computer* GetComputer(){return this->computer;}};//指导者：指挥具体的建造逻辑
class Director
{
public:Director(Builder* builder) {this->builder = builder;}//建造逻辑void BuilderComputer() {//1.建造CPUthis->builder->BuilderCpu();cout << "first make cpu"  << endl;//2.建造内存条this->builder->BuilderMemory();cout << "second make memory" << endl;//3.建造磁盘this->builder->BuilderDisk();cout << "third make disk" << endl;//4.建造显示屏this->builder->BuilderScreen();cout << "finally, make screen" << endl;}private:Builder* builder;
};//客户端
int main()
{Computer* computer = NULL;Builder* builder = NULL;Director* director = NULL;//需求：要一台dell笔记本builder = new DellBuilder(); // 先找一个dell制造厂，负责具体的创建director = new Director(builder); //指导者，指导Dell制造厂如何创建director->BuilderComputer(); //开始创建了。。。computer = builder->GetComputer(); // 待建造完毕，制造厂出货computer->ShowInfo();  //产品质检合格delete computer;delete director;delete builder;//制造Aplle比较笔记本，同理可得。return 0;
}

这篇关于设计模式 创建者模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/446193。

相关文章

Linux系统配置NAT网络模式的详细步骤(附图文)

Linux系统配置NAT网络模式的详细步骤(附图文)

《Linux系统配置NAT网络模式的详细步骤(附图文)》本文详细指导如何在VMware环境下配置NAT网络模式,包括设置主机和虚拟机的IP地址、网关,以及针对Linux和Windows系统的具体步骤,... 目录一、配置NAT网络模式二、设置虚拟机交换机网关2.1 打开虚拟机2.2 管理员授权2.3 设置子
阅读更多...
SpringBoot如何通过Map实现策略模式

SpringBoot如何通过Map实现策略模式

《SpringBoot如何通过Map实现策略模式》策略模式是一种行为设计模式,它允许在运行时选择算法的行为,在Spring框架中,我们可以利用@Resource注解和Map集合来优雅地实现策略模式,这... 目录前言底层机制解析Spring的集合类型自动装配@Resource注解的行为实现原理使用直接使用M
阅读更多...
C#原型模式之如何通过克隆对象来优化创建过程

C#原型模式之如何通过克隆对象来优化创建过程

《C#原型模式之如何通过克隆对象来优化创建过程》原型模式是一种创建型设计模式,通过克隆现有对象来创建新对象,避免重复的创建成本和复杂的初始化过程,它适用于对象创建过程复杂、需要大量相似对象或避免重复初... 目录什么是原型模式？原型模式的工作原理C#中如何实现原型模式？1. 定义原型接口2. 实现原型接口3
阅读更多...
大数据spark3.5安装部署之local模式详解

大数据spark3.5安装部署之local模式详解

《大数据spark3.5安装部署之local模式详解》本文介绍了如何在本地模式下安装和配置Spark,并展示了如何使用SparkShell进行基本的数据处理操作,同时,还介绍了如何通过Spark-su... 目录下载上传解压配置jdk解压配置环境变量启动查看交互操作命令行提交应用spark，一个数据处理框架
阅读更多...
Java实现状态模式的示例代码

Java实现状态模式的示例代码

《Java实现状态模式的示例代码》状态模式是一种行为型设计模式,允许对象根据其内部状态改变行为,本文主要介绍了Java实现状态模式的示例代码,文中通过示例代码介绍的非常详细,需要的朋友们下面随着小编来... 目录一、简介1、定义2、状态模式的结构二、Java实现案例1、电灯开关状态案例2、番茄工作法状态案例
阅读更多...
在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

1. 单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 示例代码： class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;this.data = [];}addData(value)
阅读更多...
模版方法模式template method

模版方法模式template method

学习笔记，原文链接 https://refactoringguru.cn/design-patterns/template-method 超类中定义了一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。 上层接口有默认实现的方法和子类需要自己实现的方法
阅读更多...
【iOS】MVC模式

【iOS】MVC模式

MVC模式 MVC模式MVC模式demo MVC模式 MVC模式全称为model(模型)view(视图)controller(控制器)，他分为三个不同的层分别负责不同的职责。 View：该层用于存放视图，该层中我们可以对页面及控件进行布局。Model：模型一般都拥有很好的可复用性，在该层中，我们可以统一管理一些数据。Controlller：该层充当一个CPU的功能，即该应用程序
阅读更多...
迭代器模式iterator

迭代器模式iterator

学习笔记，原文链接 https://refactoringguru.cn/design-patterns/iterator 不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素
阅读更多...
《x86汇编语言：从实模式到保护模式》视频来了

《x86汇编语言：从实模式到保护模式》视频来了

《x86汇编语言：从实模式到保护模式》视频来了 很多朋友留言，说我的专栏《x86汇编语言：从实模式到保护模式》写得很详细，还有的朋友希望我能写得更细，最好是覆盖全书的所有章节。 毕竟我不是作者，只有作者的解读才是最权威的。 当初我学习这本书的时候，只能靠自己摸索，网上搜不到什么好资源。 如果你正在学这本书或者汇编语言，那你有福气了。 本书作者李忠老师，以此书为蓝本，录制了全套视频。 试
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2