设计模式（一）——简单工厂、工厂方法、抽象工厂、建造者模式

最新推荐文章于 2024-08-20 11:15:34 发布
最新推荐文章于 2024-08-20 11:15:34 发布
阅读量353 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Seven_Yang_C/article/details/108639135
版权

文章目录

设计模式

01 简单工厂模式

简单工厂

概念

简单工厂模式：
定义一个简单工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

基本流程：

  1. 设计一个抽象产品类，它包含一些公共方法的实现
  2. 从抽象产品中派生出多个具体产品类，如篮球、足球、排球，具体产品类中实现产品生产相关的代码
  3. 设计一个工厂类，工厂类中提供一个生产各种产品的工厂方法，该方法根据传入参数（产品名称）创建不同具体产品类对象
  4. 客户只需要调用工厂类的工厂方法，并传入具体产品参数，即可得到一个具体的产品对象

三大角色：

  1. 工厂factory：根据客户提供的具体产品参数，创建具体产品的实例
  2. 抽象产品abstract product：具体产品的基类，包含创建产品的公共方法
  3. 具体产品 concrete product：抽象产品的派生类，包含具体产品特有实现方法，是简单工厂模式的创建目标

优点：

  1. 工厂类提供创建产品的方法，并包含一定的判断逻辑，客户不必参与产品的创建过程
  2. 客户只需要直到对应产品参数即可，参数一般简单好记

缺点：

  1. 新建类的时候会破坏开闭原则（对扩展开放，对修改关闭），即在扩展功能时修改了既有代码。
  2. 简单工厂模式所有的判断逻辑都在工厂类实现，一旦工厂类设计故障，整个系统都会受之影响！

SimpleFactory.h

#ifndef __SIMPLE_FACTORY__
#define __SIMPLE_FACTORY__

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

// 抽象产品类AbstractProduct
class AbstractSportProduct {
public:
	AbstractSportProduct() {}
	// 抽象方法
	void printName() {};
	void play() {};
};

// 具体产品类Basketball
class Basketball : public AbstractSportProduct {
public:
	Basketball() {
		printName();
		play();
	}
	// 具体实现方法
	void printName() { cout << "获得篮球" << endl; }
	void play() { cout << "玩耍篮球" << endl; }
};

class Football : public AbstractSportProduct {
public:
	Football() {
		printName();
		play();
	}
	// 具体实现方法
	void printName() { cout << "获得足球" << endl; }
	void play() { cout << "玩耍足球" << endl; }
};

class Volleyball : public AbstractSportProduct {
public:
	Volleyball() {
		printName();
		play();
	}
	// 具体实现方法
	void printName() { cout << "获得排球" << endl; }
	void play() { cout << "玩耍排球" << endl; }
};

class Factory {
public:
	AbstractSportProduct *getSportProduct(string productname) {
		AbstractSportProduct *pro = NULL;
		if (productname == "Basketball") pro = new Basketball();
		else if (productname == "Football") pro = new Football();
		else if (productname == "Volleyball") pro = new Volleyball();
		return pro;
	}
};

#endif __SIMPLE_FACTORY__

SimpleFactory.cpp

#include <iostream>
#include <string>
#include "SimpleFactory.h"
using namespace std;

int main() {
	cout << "简单工厂模式：" << endl;
	// 定义工厂对象
	Factory *fac = new Factory();
	AbstractSportProduct *product = NULL;

	product = fac->getSportProduct("Basketball");
	product = fac->getSportProduct("Football");
	product = fac->getSportProduct("Volleyball");
	system("pause");
	return 0;
}

02 工厂方法模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YNTpg75Z-1600313509658)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200916154440568.png)]

简单工厂模式违背了"开闭原则"，每当增加新的产品是，需要修改工厂类的逻辑。为避免这种不足，同时很好的利用简单工厂模式的优点，可以使用工厂方法模式。工厂方法模式中不再使用工厂类统一创建所有的具体产品，而是针对不同的产品设计了不同的工厂，每个工厂只生产特定的产品。

概念

工厂方法模式：
定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

四大角色：

  1. 抽象工厂AbstractFactory：所有生产具体产品的工厂的基类，提供工厂类的公共方法
  2. 具体工厂ConcreteFactory：生产具体的产品
  3. 抽象产品AbstractProduct：所有产品的基类，提供产品类的公共方法
  4. 具体产品ConcreteProduct：具体的产品类

如果需要添加新的产品，只需要添加一个新产品的工厂，在客户端代码修改具体的工厂类的类名，原有的类的代码无序修改。符合开闭原则，使用频率最高的设计模式，API类库的核心。

优点：

  1. 工厂方法用于创建客户所需产品，同时向客户隐藏某个具体产品类将被实例化的细节，用户只需关心所需产品对应的工厂；
  2. 工厂自主决定创建何种产品，并且创建过程封装在具体工厂对象内部，多态性设计是工厂方法模式的关键；
  3. 新加入产品时，无需修改原有代码，增强了系统的可扩展性，符合开闭原则。

缺点：

  1. 添加新产品时需要同时添加新的产品工厂，系统中类的数量成对增加，增加了系统的复杂度，更多的类需要编译和运行，增加了系统的额外开销；
  2. 工厂和产品都引入了抽象层，客户端代码中均使用的抽象层（AbstractFactory和AbstractSportProduct ），增加了系统的抽象层次和理解难度。

使用环境：

  1. 客户端不需要知道它所需要创建的对象的类；
  2. 抽象工厂类通过其子类来指定创建哪个对象（运用多态性设计和里氏代换原则）

FactoryMethod.h

#ifndef __FACTORY_METHOD__
#define __FACTORY_METHOD__

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

// 定义抽象产品类AbstractSportProduct，方法不提供实现
class AbstractSportProduct {
public:
	AbstractSportProduct() {}
	void printName() {};
	void play() {};
};

// 定义三个具体产品类
class Basketball :public AbstractSportProduct {
public:
	Basketball() {
		printName();
		play();
	}
	void printName() { cout << "获得篮球" << endl; }
	void play() { cout<< "玩耍篮球" <<endl; }
};

class Football :public AbstractSportProduct {
public:
	Football() {
		printName();
		play();
	}
	void printName() { cout << "获得足球" << endl; }
	void play() { cout << "玩耍足球" << endl; }
};

class Volleyball :public AbstractSportProduct {
public:
	Volleyball() {
		printName();
		play();
	}
	void printName() { cout << "获得排球" << endl; }
	void play() { cout << "玩耍排球" << endl; }
};

// 定义抽象工厂类AbstractFactory，方法为纯虚方法
class AbstractFactory {
public:
	virtual AbstractSportProduct *getSportProduct() = 0;
};

// 定义三个具体工厂类
class BasketballFactory :public AbstractFactory {
public:
	BasketballFactory() {
		cout << "篮球工厂：" << endl;
	}
	AbstractSportProduct *getSportProduct() {
		cout << "从篮球工厂获得篮球！" << endl;
		return new Basketball();
	}
};

class FootballFactory :public AbstractFactory {
public:
	FootballFactory() {
		cout << "足球工厂：" << endl;
	}
	AbstractSportProduct *getSportProduct() {
		cout << "从足球工厂获得足球！" << endl;
		return new Football();
	}
};

class VolleyballFactory :public AbstractFactory {
public:
	VolleyballFactory() {
		cout << "排球工厂：" << endl;
	}
	AbstractSportProduct *getSportProduct() {
		cout << "从排球工厂获得排球！" << endl;
		return new Volleyball();
	}
};
#endif __FACTORY_METHOD__

FactoryMethod.cpp

#include <iostream>
#include "FactoryMethod.h"

// 客户端使用方法示例
int main() {
	cout << "工厂方法模式：" << endl;
	AbstractFactory *fac = NULL;
	AbstractSportProduct *product = NULL;

	fac = new BasketballFactory();
	product = fac->getSportProduct();

	fac = new FootballFactory();
	product = fac->getSportProduct();

	fac = new VolleyballFactory();
	product = fac->getSportProduct();

	system("pause");
	return 0;
}

03 抽象工厂模式

抽象工厂模式

  1. 简单工厂模式所有逻辑都封装在工厂类中，工厂根据客户提供的产品名字创建对应产品的对象实例；
  2. 工厂方法模式将产品的创建过程放到了具体工厂类中，每一个工厂可以创建一个具体产品，由此可能会创建许多工厂类。
  3. 抽象工厂模式中一个工厂不只是生产一种产品，而是生产一类产品，可以把这些相关的产品归纳为一个“产品族”，由同一个工厂来生产。

概念

抽象工厂模式：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

四大角色

  1. 抽象工厂（AbstractFactory）：所有生产具体产品的工厂类的基类，提供工厂类的公共方法；
  2. 具体工厂（ConcreteFactory）：生产具体的产品
  3. 抽象产品（AbstractProduct）：所有产品的基类，提供产品类的公共方法
  4. 具体产品（ConcreteProduct）：具体的产品类

优点：

  1. 工厂方法用于创建客户所需产品，同时向客户隐藏某个具体产品类将被实例化的细节，用户只需关心所需产品对应的工厂；
  2. 新加入产品系列时，无需修改原有系统，增强了系统的可扩展性，符合开闭原则。

缺点：

  1. 在已有产品系列中添加新产品时需要修改抽象层代码，对原有系统改动较大，违背开闭原则

适用环境：

  1. 一系列/一族产品需要被同时使用时，适合使用抽象工厂模式；
  2. 产品结构稳定，设计完成之后不会向系统中新增或剔除某个产品

AbstractFactory.h

#ifndef __ABSTRACT_FACTORY__
#define __ABSTRACT_FACTORY__

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

// 抽象产品类AbstractBall, 球类的基类，定义抽象方法play
class AbstractBall {
public:
	AbstractBall(){}
	void play() {}
};

// 具体产品类， 分别为Basketball和Football，具体实现方法play
class Basketball :public AbstractBall {
public:
	Basketball() {
		play();
	}
	void play() {
		cout << "玩耍篮球" << endl;
	}
};

class Football :public AbstractBall {
public:
	Football() {
		play();
	}
	void play() { cout << "玩耍足球" << endl; }
};

// 抽象产品类AbstractShirt：球衣类的基类，定义抽象方法wearShirt
class AbstractShirt
{
public:
	AbstractShirt() {}
	//抽象方法：
	void wearShirt() {};
};

// 具体产品类BasketballShirt和FootballShirt，具体实现方法wearShirt
class BasketballShirt :public AbstractShirt
{
public:
	BasketballShirt() {
		wearShirt();
	}
	void wearShirt() { cout << "穿着篮球服" << endl; }
};

class FootballShirt :public AbstractShirt
{
public:
	FootballShirt() {
		wearShirt();
	}
	void wearShirt() { cout << "穿着足球服" << endl; }
};

// 定义抽象工厂AbstractFactory，声明两个方法getBall和getShirt
class AbstractFactory
{
public:
	virtual AbstractBall *getBall() = 0;
	virtual AbstractShirt *getShirt() = 0;
};

// 定义具体工厂BasketballFactory和FootballFactory，重新具体实现两个方法getBall和getShirt
class BasketballFactory :public AbstractFactory
{
public:
	BasketballFactory(){ cout << "获得篮球" << endl; }
	AbstractBall *getBall(){
		cout << "获得篮球" << endl;
		return new Basketball();
	}
	AbstractShirt *getShirt(){
		cout << "穿着篮球服" << endl;
		return new BasketballShirt();
	}
};

class FootballFactory :public AbstractFactory
{
public:
	FootballFactory(){ cout << "足球工厂" << endl; }
	AbstractBall *getBall(){
		cout << "获得足球" << endl;
		return new Football();
	}
	AbstractShirt *getShirt(){
		cout << "穿着足球服" << endl;
		return new FootballShirt();
	}
};
#endif __ABSTRACT_FACTORY__

AbstractFactory.cpp

#include <iostream>
#include "AbstractFactory.h"

// 客户端使用方法示例
int main() {
	printf("抽象工厂模式\n");

	//定义工厂类对象和产品类对象
	AbstractFactory *fac = NULL;
	AbstractBall *ball = NULL;
	AbstractShirt *shirt = NULL;

	fac = new BasketballFactory();
	ball = fac->getBall();
	shirt = fac->getShirt();

	fac = new FootballFactory();
	ball = fac->getBall();
	shirt = fac->getShirt();

	system("pause");
	return 0;
}

04 建造者模式

建造者模式
概念

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

四大角色

  1. 抽象建造者（AbstractBuilder）：创建一个Product对象的各个部件指定的抽象接口；
  2. 具体建造者（ConcreteBuilder）：实现AbstractBuilder的接口，实现各个部件的具体构造方法和装配方法，并返回创建结果；
  3. 产品（Product）：具体的产品对象；
  4. 指挥者（Director）：构建一个使用Builder接口的对象，安排复杂对象的构建过程，客户端一般只需要与Director交互，指定建造者类型，然后通过构造函数或者setter方法将具体建造者对象传入Director。它主要的作用是：隔离客户与对象的生产过程，并负责控制产品对象的生产过程。

优点：

  1. 建造者模式中，客户端不足要知道产品内部组成细节，将产品本身和产品的创建过程分离，使同样的创建过程可以创建不同的产品对象；
  2. 不同建造者相互独立，并无任何挂链，方便替换。

缺点：

  1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围收到一定的限制；
  2. 如果产品内部变化复杂，可能会导致需要定义很多具体见在这类来实现这种变化，导致系统变得很庞大。

适用环境：

  1. 需要生产的产品对象有复杂的内部结构（通常包含很多个成员变量）
  2. 产品对象内部属性具有一定的生成顺序；
  3. 同一个创建流程适用于多种不同的产品。

BuilderPattern.h

#ifndef __BUILDER_PATTERN__
#define __BUILDER_PATTERN__

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

// 定义产品类House
class House {
public:
	House() {}
	void setFloor(string iFloor) { this->floor = iFloor; }
	void setWall(string iWall) { this->wall = iWall; }
	void setRoof(string iRoof) { this->roof = iRoof; }
	void printHouseInfo() {
		cout << this->floor << endl;
		cout << this->wall << endl;
		cout << this->roof << endl;
	}

private:
	string floor;
	string wall;
	string roof;
};

// 定义抽象建造者AbstractBuilder
class AbstractBuilder {
public:
	AbstractBuilder() { house = new House; }
	virtual void builderFloor() = 0;
	virtual void builderWall() = 0;
	virtual void builderRoof() = 0;
	virtual House *getHouse() = 0;
	House *house;
};

// 定义具体的建造者
class ConcreteBuilderA :public AbstractBuilder {
public:
	ConcreteBuilderA() { cout << "ConcreteBuilderA" << endl; }
	void builderFloor() { this->house->setFloor("Floor_A"); }
	void builderWall() { this->house->setWall("Floor_A"); }
	void builderRoof() { this->house->setRoof("Roof_A"); }

	House *getHouse() { return this->house; }
};

class ConcreteBuilderB :public AbstractBuilder {
public:
	ConcreteBuilderB() { cout << "ConcreteBuilderB" << endl; }
	void builderFloor() { this->house->setFloor("Floor_B"); }
	void builderWall() { this->house->setWall("Floor_B"); }
	void builderRoof() { this->house->setRoof("Roof_B"); }

	House *getHouse() { return this->house; }
};

// 定义指挥者
class Director {
public:
	Director(){}
	void setBuilder(AbstractBuilder *iBuilder) { this->builder = iBuilder; }
	// 封装组装流程，返回建造结果
	House *constructor() {
		builder->builderFloor();
		builder->builderWall();
		builder->builderRoof();
		return builder->getHouse();
	}
private:
	AbstractBuilder *builder;
};
#endif __BUILDER_PATTERN__

BuilderPattern.cpp

#include "BuilderPattern.h"

int main() {
	// 抽象建造者
	AbstractBuilder *builder;
	// 指挥者
	Director *director = new Director();
	// 产品
	House *house;

	// 指定具体建造者A
	builder = new ConcreteBuilderA();
	director->setBuilder(builder);
	house = director->constructor();
	house->printHouseInfo();

	// 指定具体的建造者B
	builder = new ConcreteBuilderB();
	director->setBuilder(builder);
	house = director->constructor();
	house->printHouseInfo();

	system("pause");
	return 0;
}
SevenShanwen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中常见的设计模式—工厂模式
守夜人爱吃兔子的博客
08-22 3074
前言 今天来和小伙伴们分享下设计模式中的工厂模式啦 ​ 一、工厂模式 我们都知道，设计模式有23种，按照功能和使用场景可以分为三大类： 创建型模式 结构型模式 行为型模式 工厂设计模式（Factory Pattern）呢，就是一种很常见的设计模式，属于创建型模式的，主要作用就是来创建对象的~ 原理图 ​ 先来看一个小栗子 二、简单工厂模式（非23种） 原理图 ​ 例子的话，感觉也挺多的 比如各种品牌的电脑呀，手机呀，家具呀…… 比如笔记本电脑的例子 抽取公共接口
设计模式详解（一）——工厂方法模式
weixin_41951205的博客
09-18 445
前言 前面我们介绍了简单工厂模式，它将创建对象的细节隐藏起来，客户端仅仅通过参数来决定生产哪种具体的产品。但是该模式有个较大的缺点，当我们增加新产品的时候就需要修改工厂类的逻辑，导致原来的商品创建逻辑可能受到影响，即违背了开闭原则。因此我们提出了工厂方法模式。 一、场景问题 在实际工作中，我们经常需要导出一些数据，这些数据可能是Excel模式、文本格式、XML格式或数据库脚本格式等等，总之一系列的数据文件格式，未来也有各种各样的导出格式需求. 二、解决方案 1、传统解决方案 即简单工厂模式，缺点上面也说明了
设计模式——工厂方法模式
在梅边的专栏
01-22 162
工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实现延迟到其子类。 示例代码如下：// 抽象产品类代码 public abstract class Product { public void method1(){ // 公共方法 } // 抽象方法 public abstract void method2();}//
设计模式之工厂方法和抽象工厂
程序员田同学的博客
07-28 407
全网最详细的工厂设计模式，本文主要是创建型设计模式中的工厂方法和抽象工厂，先由传统实现方式引出问题，接着对代码改进到简单工厂，后扩展到工厂方法，最后是抽象工厂模式，文中包括概念理解和相关实现代码。...
抽象工厂模式与建造者模式——用一个实例来解释
虚幻的元亨利贞.的博客
04-06 1428
最近在学习设计模式，在创建型模式中比较难理解的主要是工厂模式与建造者模式，二者有许多相似之处，但是本质上还是不同的。 1.抽象工厂模式：是工厂模式的一种。工厂模式又分为工厂方法模式与抽象工厂模式。工厂方法模式在本文中不进行详细叙述，简单来说就是给一个工厂负责创建一个类。而抽象工厂模式负责创建一个产品族，例如本文要举的例子中，男士帽子、男士大衣、男士裤子属于一个产品族；女士帽子、女士大衣、女士裤子属于另一个产品族。如果只用工厂方法模式，那就需要创建6个工厂类。而用抽象工厂模式只需要2个工厂类，分别是Mal
设计模式（简单工厂、工厂方法、抽象工厂模式）
qq_41123884的博客
05-05 523
作业四
学不会你来砍我！设计模式之工厂模式
12-21
然而，工厂模式也有其局限性，例如，如果工厂类变得过于复杂，可能需要考虑使用更复杂的工厂模式，如抽象工厂模式或建造者模式。此外，如果过度使用静态工厂方法，可能会导致代码难以测试，因为它不易于进行依赖注入...
设计模式之美——教你写出高质量代码
04-10
1. 创建型模式：包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。这些模式主要关注对象的创建过程，使得对象的实例化过程更加灵活，同时能够控制类的实例数量。 2. 结构型模式：如适配器模式、...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
1. **创建型模式**：包括单例（Singleton）、工厂方法（Factory Method）、抽象工厂（Abstract Factory）、建造者（Builder）和原型（Prototype）。这些模式关注对象的创建过程，使得代码更加灵活，易于管理和扩展。...
设计模式——刘伟
03-15
分为简单工厂、工厂方法和抽象工厂三种类型。 3. **观察者模式**：定义对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在事件驱动编程中广泛使用，例如GUI组件...
设计模式——JAVA.docx
04-03
- **创建型模式**（共5种）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 - **结构型模式**（共7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 - **行为型...
抽象工厂模式和建造者模式-java设计模式第四次课学习总结
m0_48333563的博客
04-02 376
抽象工厂模式和建造者模式1.抽象工厂模式：1.1.如何使用抽象工厂模式？1.2.模式分析：1.3.模式实例与解析1.4.模式优缺点1.4.1.抽象工厂模式的优点1.4.2.抽象工厂模式的缺点2.建造者模式：2.1.如何使用建造者模式？2.2.模式结构2.3.模式分析2.4.模式优缺点2.4.1.建造者模式的优点2.4.2.建造者模式的缺点如下：2.5.建造者模式与抽象工厂模式的比较 1.抽象工厂模式： 背景：工厂方法模式针对于每种具体产品都有对应的工厂。 目的：一个工厂可以提供多个产品对象，而不是单一的产品
【再探】设计模式—抽象工厂及建造者模式
KEEP CODING
04-30 892
抽象工厂模式和建造者模式都属于创建型模式。两者都能创建对应的对象，而创建者模式更侧重于创建复杂对象，将对象的创建过程封装起来，让客户端不需要知道对象的内部细节。
对 工厂模式与建造者模式 的个人理解，以及结合运用
热门推荐
MonkeyD5的博客
06-20 1万+
学习了一段时间设计模式，就想分享一下自己的理解， 欢迎大家多多指点，指出不足之处哈 个人理解，工厂模式用于处理 如何获取实例对象 问题，建造者模式用于处理 如何建造实例对象 问题（好像是废话。。。）。两者应该可以结合起来，下面将以商店售卖手机这场景来描述。 工厂模式： 简单工厂模式-工厂方法模式： 简单工厂模式却由Simpl
设计模式之---工厂模式、建造者模式
伟庭的博客
06-08 1308
设计模式之---工厂模式、建造者模式
工厂模式与建造者模式
新新新的博客丶
05-23 2446
工厂模式和建造者模式都属于创建型模式，它对类的实例化进行了抽象，能够使软件模块做到与对象的创建和组织无关。简单工厂模式专门定义一个类来负责创建其他类的实例，通常根据自变量的不同而返回不同的类的实例。工厂类 public class MoblieFactor{ public Mobile getMobile(String title) { if(title.equals("noki...
设计模式之工厂模式（简单工厂、工厂方法、抽象工厂）
d303577562的博客
04-29 276
定义 简单工厂模式（Simple Factory Pattern）：由一个工厂对象决定创建哪一种产品类的实例。 简单工厂模式是工厂模式的小弟，它不属于GOF23中设计模式之一。但是平常应用也比较频繁。 在简单工厂模式中创建实例的方法通常为静态（static）方法，因此简单工厂模式（Simple Factory Pattern）又叫静态工厂方法模式（static Factory Method Pattern）。 优点 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产
设计模式 -- 七大原则（一）-- 单一职责原则
最新发布
qq_67342067的博客
08-20 307
单一职责原则是面向对象设计中的一个核心原则，它鼓励开发者将复杂的系统分解为多个小而专的模块，每个模块负责一个职责。这样做不仅提高了代码的可维护性、可读性和可扩展性，还降低了代码的复杂性和出错的概率。
理解AF：软件设计模式解析——工厂方法与简单工厂模式
"AF-戏说软件设计模式讨论了为何需要设计模式，特别是工厂方法模式和简单工厂模式在软件开发中的应用。" 在软件工程中，设计模式是一种被广泛接受和重复使用的解决方案，用于处理在特定上下文中经常遇到的问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值