【设计模式】创建者模式_工厂、抽象工厂、建造者

已于 2022-08-24 07:57:12 修改
阅读量397 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 c++
于 2022-08-24 01:07:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41943808/article/details/126495815
版权

设计模式六大原则

  • 开闭原则(Open Close Principle)

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码。

  1. 单一职责原则

不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。

  1. 里氏替换原则

里氏代换原则(Liskov Substitution Principle LSP)中说，任何基类可以出现的地方，一定可以用其子类替换。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

  1. 依赖倒换原则

面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

  1. 接口隔离原则

每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。

  1. 迪米特法则(最少知道原则)

一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

  1. 合成复用原则

尽量首先使用合成/聚合的方式，而不是使用继承。

创建型模式

  1. 工厂模式

简单工厂 工厂方法模式 抽象工厂模式

有一家物流公司，可以提供不同类型的运输工具，进行物流运输。客户要走陆运，就从公司里要一辆卡车，要海运就从公司要一艘船

enum VTYPE {SHIP, TRUCK};     
class Vehicles
{    
public:    
    virtual void Show() = 0;  
};    
//陆运    
class Truck: public Vehicles    
{    
public:    
    void Show() { cout<<"This is a truck"<<endl; }    
};    
//海运    
class Ship: public Vehicles    
{    
public:    
    void Show() { cout<<"This is a ship"<<endl; }    
};    
//唯一的工厂，可以生产不同的载具，在内部判断    
class Factory    
{    
public:     
    Vehicles* CreateVehicles(enum VTYPE Vtype)    
    {    
        if(Vtype == SHIP) //工厂内部判断    
            return new Ship(); //生产船
        else if(Vtype == TRUCK)    
            return new Truck(); //生产卡车
        else    
            return nullptr;    
    }    
};
  • 要增加一个新的载具类型，需要修改工厂类，违背开闭原则

所以出现了工厂方法，不再通过修改工厂实现，而实创建新的工厂

  • 模式定义
  • 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到子类完成。
#include <iostream>
using namespace std;

class Vehicles
{
public:
    virtual void Show() = 0;
};
//陆运    
class Truck : public Vehicles
{
public:
    void Show() { cout << "This is a truck" << endl; }
};
//海运    
class Ship : public Vehicles
{
public:
    void Show() { cout << "This is a ship" << endl; }
};
class Factory
{
public:
    virtual Vehicles* CreateVehicle() = 0;
};
//生产船的工厂    
class FactoryShip : public Factory
{
public:
    Ship* CreateVehicle() { return new Ship(); }
};
//生产卡车的工厂    
class FactoryTruck : public Factory
{
public:
    Truck* CreateVehicle() { return new Truck(); }
};

int main()
{
    FactoryTruck *m_TruckFactory = new FactoryTruck();
    FactoryShip *m_ShipFactory = new FactoryShip();

    Vehicles* m_Truck = m_TruckFactory->CreateVehicle();
    m_Truck->Show();

    Vehicles* m_Ship = m_ShipFactory->CreateVehicle();
    m_Ship->Show();

    return 0;

}
  • 问题在于 每增加一种产品，就会增加一个工厂类

现在公司业务升级，提供了更大载荷的承运方案，需要生产不同规格的卡车、轮船

#include <iostream>
using namespace std;

class Vehicles
{
public:
    virtual void Show() = 0;
};
//陆运    
class Truck : public Vehicles
{
public:
    void Show() { cout << "This is a truck" << endl; }
};
//海运    
class Ship : public Vehicles
{
public:
    void Show() { cout << "This is a ship" << endl; }
};
//大型载具    
class BigVehicles
{
public:
    virtual void Show() = 0;
};
class BigTruck : public BigVehicles
{
public:
    void Show() { cout << "This is a BIG truck" << endl; }

};
class BigShip : public BigVehicles
{
public:
    void Show() { cout << "This is a BIG ship" << endl; }
};
//工厂    
class Factory
{
public:
    virtual Vehicles* CreateVehicles() = 0;
    virtual BigVehicles* CreateBigVehicles() = 0;
};
//卡车工厂，生产大型、小型卡车
class FactoryTruck :public Factory
{
public:
    Vehicles* CreateVehicles() { return new Truck(); }
    BigVehicles* CreateBigVehicles() { return new BigTruck(); }
};
//船工厂，生产大型、小型船
class FactoryShip : public Factory
{
public:
    Vehicles* CreateVehicles() { return new Ship(); }
    BigVehicles* CreateBigVehicles() { return new BigShip(); }
};

int main()
{
    FactoryTruck* m_TruckFactory = new FactoryTruck();
    FactoryShip* m_ShipFactory = new FactoryShip();

    Vehicles* m_Truck = m_TruckFactory->CreateVehicles();
    Vehicles* m_Ship = m_ShipFactory->CreateVehicles();

    BigVehicles* m_BigTruck = m_TruckFactory->CreateBigVehicles();
    BigVehicles* m_BigShip = m_ShipFactory->CreateBigVehicles();

    m_Ship->Show();
    m_Truck->Show();
    m_BigShip->Show();
    m_BigTruck->Show();

    return 0;
}

  • 如果需要拓展抽象工厂里面的方法会比较麻烦，因为我们必须修改抽象类以及添加对应的产品，这样修改量比较大，但是每种产品之间相互解耦。

  1. 建造者模式
  • 模式意图
    将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

特点： 用于对复杂对象的构造、初始化，与工厂模式不同的是，建造者的目的在于把复杂构造过程从不同对象展现中抽离出来，使得同样的构造工序可以展现出不同的产品对象。

  • 适用场景

  • 相同的方法，不同的执行顺序，产生不同的结果时，可以采用建造者模式。

  • 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

  • 产品类非常复杂，或者产品类中的方法调用顺序不同产生了不同的效能，这个时候使用建造者模式。

都builder了，就举一个盖房子的例子
比如盖一栋房子需要 地基 墙体 房顶三部分组成

我们创建建筑物类Building
抽象出建造方法类Builder
创建一个HouseBuilder用来描述具体各部件的构造方式
最后用Director类对构造流程进行管理，通过它选择不同的构造方式，并明确具体的构造流程，最终得到我们的复杂产品

#include <iostream>
#include <vector>
using namespace std;

class Building
{
private:
	vector<string> BuildingComponents;
public:
	void SetBasement(string basement) {
		BuildingComponents.push_back(basement);
	}
	void SetWall(string wall) {
		BuildingComponents.push_back(wall);
	}
	void SetRoof(string roof) {
		BuildingComponents.push_back(roof);
	}

	void PrintBuilding() {
		for (int i = BuildingComponents.size() - 1; i >= 0; i--) {
			cout << BuildingComponents[i] << endl;
		}
		return;
	}
};

class Builder
{
public:
	virtual void BuildBasement() = 0;
	virtual void BuildWall() = 0;
	virtual void BuildRoof() = 0;
	virtual void GetBuilding() = 0;
};

class HouseBuilder : public Builder
{
private:
	Building house;

public:
	void BuildBasement() {
		house.SetBasement("这里是house地基");
	}
	void BuildWall() {
		house.SetWall("这里是house墙壁");
	}
	void BuildRoof() {
		house.SetRoof("  house房顶！  ");
	}
	void GetBuilding() {
		house.PrintBuilding();
	}
};

class Director
{
private:
	Builder* m_pBuilder;
public:
	Director(Builder* builder) { m_pBuilder = builder; }
	void Create() {
		m_pBuilder->BuildBasement();
		m_pBuilder->BuildWall();
		m_pBuilder->BuildWall();
		m_pBuilder->BuildWall();
		m_pBuilder->BuildWall();
		m_pBuilder->BuildRoof();
		m_pBuilder->GetBuilding();
	}
};

int main()
{
	HouseBuilder ahouse;
	Director director(&ahouse);
	director.Create();
	return 0;
}
  1. 原型模式
  • 模式意图
    用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象

特点：

  • 性能较好，原型模式是内存二进制流的复制，会比直接new一个对象性能较好
  • 因为是直接复制，所以绕开了构造函数，这是优点也是缺点，要看实际使用场景
#include <iostream>
using namespace std;
//具体的实现类
class Sheep
{
public:
    Sheep(int id, string name) :m_id(id), m_name(name)
    {

        cout << "new Sheep Comes" << endl;
    }

    //关键代码拷贝构造函数
    Sheep(const Sheep& obj)
    {
        this->m_id = obj.m_id;
        this->m_name = obj.m_name;
    }
    //关键代码克隆函数，返回return new Sheep(*this)
    Sheep* clone()
    {
        return new Sheep(*this);
    }
    void show()
    {
        cout << "id  :" << m_id << endl;
        cout << "name:" << m_name.data() << endl;
        cout << "Sheep id address:" << &m_id << endl;
        cout << "Sheep name address:" << &m_name << endl;
    }
private:
    int m_id;
    string m_name;
};
int main()
{
    Sheep* s1 = new Sheep(9, "肖恩");
    s1->show();
    Sheep* s2 = s1->clone();
    s2->show();
    return 0;
}
Krifood
关注
专栏目录
Java设计模式-建造者模式详解
11-24
Java设计模式-建造者模式详解 Java设计模式-建造者模式详解将一个复杂对象的构建与它的表示...同时，Builder模式也可以与其他设计模式结合使用，例如工厂模式、抽象工厂模式等，以实现更加灵活和可控的对象构建过程。
23种设计模式----创建型模式
weixin_30853329的博客
05-26 137
创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。 创建型模式分为以下几种。 单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。 原型（Prototype）模式：将一个对象作为原型，通过对其进行复...
设计模式(工厂模式,抽象工厂模式)
m0_47254108的博客
06-21 172
序号模式 & 描述包括1创建型模式 这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。2结构型模式 这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。3行为型模式 这些设计模式特别关注对象之间的通信。4J2EE 模式 这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。1、开闭原则（Open Close Pr
day02 工厂模式+原型模式+建造者模式
10-18
设计模式之工厂模式、原型模式和建造者模式 设计模式是一种软件设计的解决方案，能够使我们的代码更加灵活、可维护和可扩展。今天，我们将讨论三种设计模式：工厂模式、原型模式和建造者模式。 工厂模式 工厂模式...
Java设计模式之建造者模式实例详解
08-29
在Java中，建造者模式的实现方法是使用抽象工厂模式和建造者模式相结合。首先，定义一个抽象产品类，例如`Product`，然后定义具体的产品类，例如`Movie`和`Book`。接着，定义一个抽象建造者类，例如`Builder`，然后...
php设计模式 Builder(建造者模式)
12-19
与其他设计模式结合使用，如工厂模式（用于创建建造者对象）、策略模式（用于定义不同的构建策略），可以进一步提高代码的复用性和可维护性。 总的来说，PHP中的建造者模式提供了一种结构化的方式来创建复杂对象，...
javascript设计模式 – 建造者模式原理与应用实例分析
10-15
建造者模式是设计模式中的一种，属于创建型模式，它主要用来解决复杂对象的构建问题。在JavaScript中，建造者模式允许我们隔离产品的构建过程，同时保持构建过程的灵活性，使得构建不同类型的复杂对象变得简单。 ...
c++设计模式demo
jianfeng123123的博客
11-06 656
⾼层模块不应该依赖低层模块，⼆者都应该依赖抽象；抽象不应该依赖具体实现，具体实现应该依赖于抽象；⾃动驾驶系统公司是⾼层，汽⻋⽣产⼚商为低层，它们不应该互相依赖，⼀⽅变动另⼀⽅也会跟着变动；⽽应该 抽象 ⼀个⾃动驾驶⾏业标准，⾼层和低层都依赖它；这样以来就解耦了两⽅的变动；⾃动驾驶系统、汽⻋⽣产⼚商都是具体实现，它们应该都依赖⾃动驾驶⾏业标准（抽象）；⼀个类应该对扩展开放，对修改关闭；不将变量类型声明为某个特定的具体类，⽽是声明为某个接⼝。
JavaScript 23种经典设计模式简介
前端梦工厂
11-06 909
23种JavaScript经典设计模式。
设计模式之——观察者模式
m0_71974552的博客
11-07 909
深入理解观察者模式：高效解耦的设计利器
设计模式小结一策略（strategy）模式
sunxingzhesunjinbiao的专栏
11-04 1215
定义一个策略接口，包含一个计算折扣价格的方法。// 折扣策略接口创建类，用于设置折扣策略，并计算折扣后的价格。// 设置折扣策略// 计算折扣价格throw new IllegalStateException("折扣策略未设置");
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 165
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
MVC（Model-View-Controller）模式概述
Joshua的专栏
11-03 634
以下是对 Smalltalk 的 MVC 架构模式的设计思想、采用的重要设计模式以及其后续发展的详细说明。Smalltalk 的 MVC 架构模式不仅是一种设计思想，也是一系列设计模式的集合，旨在实现软件开发中关注点的分离。这种设计模式有效地提高了程序的可维护性和可扩展性，并在后续的编程语言和开发框架中得到了广泛运用和发展。MVC 的演变和适应现代需求的能力，展示了其在软件设计领域的重要性和持久性。MVC 模式在 Smalltalk 的成功应用之后，广泛影响了后续的编程语言和开发框架。
GOF的C++软件设计模式的分类和模式名称
Joshua的专栏
11-03 973
根据他们解决问题的性质，设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。设计模式的使用不仅可以提升代码的可读性和可维护性，还能提高代码的复用性和灵活性。理解这些模式及其应用场景将有助于设计出更高质量的软件系统。创建型模式主要关注如何创建对象，目的是通过使用不同的方式来创建对象，从而增强程序的灵活性和可复用性。结构型模式关注类或对象的组合，旨在通过组合现有类或对象来形成更大的结构。行为型模式主要关注对象之间的交互，提供了对象之间的责任分配和通信方式。
【设计模式系列】组合模式（十二）
LHW0621的专栏
11-03 1079
组合模式的核心思想是将对象组合成树状结构，使得单个对象和对象的组合能够以相同的方式被处理。
【设计模式】结构型模式（二）：代理模式
书山有路，学海无涯。记录成长，追逐梦想
11-03 922
代理模式（Proxy Pattern）是一种结构型设计模式，它允许你提供一个代理对象来控制对某个对象的访问。代理对象可以执行一些额外的操作，如 权限检查、日志记录、延迟初始化 等，然后再将请求转发给实际的对象。
《重学Java设计模式》之 原型模式
WaaTong的博客
11-07 123
原型模式主要解决的问题就是创建重复对象，而这部分对象内容本身比较复杂，生成过程可能从库或者RPC接口中获取数据的耗时较长，因此采用克隆的方式节省时间。案例：上机考试抽题，要求打乱题目、答案数据。
【设计模式系列】外观模式（十四）
LHW0621的专栏
11-03 689
外观模式的核心目的是为一个复杂的子系统提供一个简化的接口。
软件工程中的创建型设计模式：工厂方法模式与抽象工厂模式
最新发布
apple_64847327的博客
11-07 695
抽象工厂模式则更为复杂，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定它们的具体类。这种模式适用于对象族的创建，其中对象之间存在一定的依赖关系。设计模式是软件工程中的重要工具，它们帮助我们写出更加优雅、可维护和可扩展的代码。工厂方法模式和抽象工厂模式是创建型设计模式中的两个重要成员，它们在不同的场景下发挥着关键作用。理解这些模式的核心概念和应用场景，将有助于我们在面对复杂的对象创建问题时，做出更合理的设计决策。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值