大话设计模式——工厂模式

最新推荐文章于 2022-08-31 11:24:55 发布
最新推荐文章于 2022-08-31 11:24:55 发布
阅读量276 收藏
点赞数
分类专栏： C++ 设计模式 文章标签： c++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Acquisition0818/article/details/117468523
版权

1. 简单工厂模式（Simple Factory Pattern）

简单工厂模式包含三个角色：

  • 抽象产品类：一般为具体产品继承的父类 或者 实现的接口
  • 具体产品类：继承 或 实现 抽象产品类角色，在工厂类 中 创建此类的 实例（对象）。
  • 工厂类：本模式的核心，含有一定的逻辑判断，根据逻辑不同返回不同的具体工厂产品（利用了多态）。

简单工厂模式适用于业务较简单的情况，一般用于小项目或者具体产品很少扩展的情况。
（扩展产品需要修改工厂类，违反开闭原则）

在这里插入图片描述

#include <iostream>
using namespace std;

class Calculator {
public:
	virtual float getResult(float num1, float num2) = 0;
};

class AddCalculator :public Calculator { //加法
public:
	float getResult(float num1, float num2) {
		return num1 + num2;
	}
};
class SubCalculator :public Calculator { //减法
public:
	float getResult(float num1, float num2) {
		return num1 - num2;
	}
};
class MulCalculator :public Calculator { //乘法
public:
	float getResult(float num1, float num2) {
		return num1 * num2;
	}
};
class DivCalculator :public Calculator {  //除法
public:
	float getResult(float num1, float num2) {
		if (num2 > -0.000001 && num2 < 0.000001) {
			throw "error of dividing zero.";
		}
		else {
			return num1 / num2;
		}
	}
};

//***********************************//
//创建运算工厂 ——简单工厂模式  如果新增加运算方法，需要更改原代码，不符合开闭原则
class CalculatorSimpleFactory {
public:
	// 静态方法
	static Calculator* createCalculator(char cType) {
		switch (cType)
		{
		case '+':
			return new AddCalculator;
			break;
		case '-':
			return new SubCalculator;
			break;
		case '*':
			return new MulCalculator;
			break;
		case '/':
			return new DivCalculator;
			break;
		default:
			return NULL;
			break;
		}
	}
	
};

void test01(float num1, float num2, char cType) {
	
	Calculator* cal = CalculatorSimpleFactory::createCalculator(cType);  //静态方法的调用
	cout << cal->getResult(num1, num2) << endl;
	delete cal;
}
//***********************************//
int main() {
	try {
		float numberA;
		cout << "请输入数字A：";
		cin >> numberA;

		char cType;
		cout << "请选择运算符号（+、-、*、/）：";
		cin >> cType;

		float numberB;
		cout << "请输入数字B：";
		cin >> numberB;

		test01(numberA, numberB, cType);
	}
	catch (const char* error) {   //注意这里是 char 类型
		cout << error << endl;
	}

	return 0;
}

策略模式
在这里插入图片描述

//***********************************//
//策略模式 
class CalculatorContext {          //维护一个 对 Calculator 对象的引用
public:
	CalculatorContext(Calculator* cal) {
		mCal = cal;
	}
	float getResult(float num1, float num2) {
		return mCal->getResult(num1, num2);
	}
private:
	Calculator* mCal;
};

void test01(float num1, float num2, char cType) {

	CalculatorContext* calContext;

	switch (cType)
	{
	case '+':
		calContext = new CalculatorContext(new AddCalculator);
		cout << calContext->getResult(num1, num2) << endl;
		break;
	case '-':
		calContext = new CalculatorContext(new SubCalculator);
		cout << calContext->getResult(num1, num2) << endl;
		break;
	case '*':
		calContext = new CalculatorContext(new MulCalculator);
		cout << calContext->getResult(num1, num2) << endl;
		break;
	case '/':
		calContext = new CalculatorContext(new DivCalculator);
		cout << calContext->getResult(num1, num2) << endl;
		break;
	default:
		break;
	}

}
//***********************************//

简单工厂与策略模式结合

//***********************************//
//简单工厂 + 策略模式
class CalculatorContextPro {
public:
	CalculatorContextPro(char cType) {

		switch (cType)
		{
		case '+':
			mCal = new AddCalculator;
			break;
		case '-':
			mCal = new SubCalculator;
			break;
		case '*':
			mCal = new MulCalculator;
			break;
		case '/':
			mCal = new DivCalculator;
			break;
		default:
			mCal = NULL;
			break;
		}
	}
	float getResult(float num1, float num2) {
		return mCal->getResult(num1, num2);
	}
private:
	Calculator* mCal;
};

void test01(float num1, float num2, char cType) {

	CalculatorContextPro* calContextPro = new CalculatorContextPro(cType);
	cout << calContextPro->getResult(num1, num2) << endl;
}
//***********************************//

对比简单工厂 与 策略模式和简单工厂结合的用法

//简单工厂
void test01(float num1, float num2, char cType) {
	
	Calculator* cal = CalculatorSimpleFactory::createCalculator(cType);  //静态方法的调用
	cout << cal->getResult(num1, num2) << endl;
	delete cal;
}
//简单工厂和策略模式结合
void test01(float num1, float num2, char cType) {

	CalculatorContextPro* calContextPro = new CalculatorContextPro(cType);
	cout << calContextPro->getResult(num1, num2) << endl;
}

简单工厂模式需要让客户端 认识 两个类 抽象类（Calculator） 和工厂类（CalculatorSimpleFactory）
简单工厂和策略模式结合 只需客户端 认识一个类 CalculatorContextPro 即可。

2. 工厂方法模式（Factory Method Pattern）

在这里插入图片描述

//***********************************//
//工厂方法模式
class CalculatorFactory {
public:
	virtual Calculator* createCalculator() = 0;
};

class AddCalculatorFactory :public CalculatorFactory {
public:
	virtual Calculator* createCalculator() {
		return new AddCalculator;
	}
};
class SubCalculatorFactory :public CalculatorFactory {
public:
	virtual Calculator* createCalculator() {
		return new SubCalculator;
	}
};
class MulCalculatorFactory :public CalculatorFactory {
public:
	virtual Calculator* createCalculator() {
		return new MulCalculator;
	}
};
class DivCalculatorFactory :public CalculatorFactory {
public:
	virtual Calculator* createCalculator() {
		return new DivCalculator;
	}
};


void test01(float num1, float num2, char cType) {

	switch (cType)
	{
	case '+':
	{
		CalculatorFactory* calFactory = new AddCalculatorFactory;
		Calculator* addCal = calFactory->createCalculator();
		cout << addCal->getResult(num1, num2) << endl;
		break;
	}		
	case '-':
	{
		CalculatorFactory* subCal = new SubCalculatorFactory;
		cout << subCal->createCalculator()->getResult(num1, num2) << endl;
		break;
	}
	case '*':
	{
		CalculatorFactory* mulCal = new MulCalculatorFactory;
		cout << mulCal->createCalculator()->getResult(num1, num2) << endl;
		break;
	}
	case '/':
	{
		CalculatorFactory* divCal = new DivCalculatorFactory;
		cout << divCal->createCalculator()->getResult(num1, num2) << endl;
		break;
	}
	default:
		break;
	}
	
}

//***********************************//
//main 函数同上

简单工厂 与 工厂方法 比较：
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户的选择条件动态实例化相关的类，对客户端来说，去除了与具体产品的依赖。
工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现 Calculator 类，选择判断问题还是存在的，也就是说，工厂方法把简单工厂的内部逻辑判断转移到了 客户端 代码中实现，如增加功能，本来改工厂类的，现在需要修改客户端。

3. 抽象工厂模式（Abstract Factory Pattern）

理解产品族和产品等级

产品族：一个品牌下面的所有产品；例如华为下面的加法器，减法器，乘法器，除法器 称为华为的产品族；

产品等级：多个品牌下面的同种产品；例如华为和小米下面的加法器 称为一个产品等级；
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;

class AddCalculator {
public:
	virtual float getResult(float num1, float num2) = 0;
};

class AddCalculatorA :public AddCalculator { 
public:
	float getResult(float num1, float num2) {
		cout << "AddCalculatorA:";
		return num1 + num2;
	}
};
class AddCalculatorB :public AddCalculator { 
public:
	float getResult(float num1, float num2) {
		cout << "AddCalculatorB:";
		return num1 + num2;
	}
};

class SubCalculator {
public:
	virtual float getResult(float num1, float num2) = 0;
};

class SubCalculatorA :public SubCalculator {
public:
	float getResult(float num1, float num2) {
		cout << "SubCalculatorA:";
		return num1 - num2;
	}
};
class SubCalculatorB :public SubCalculator {
public:
	float getResult(float num1, float num2) {
		cout << "SubCalculatorB:";
		return num1 - num2;
	}
};


//***********************************//
//抽象工厂模式
class CalculatorAbstractFactory {
public:
	virtual AddCalculator* createAddCalculator() = 0;
	virtual SubCalculator* createSubCalculator() = 0;
};

class CalculatorAFactory :public CalculatorAbstractFactory {
public:
	virtual AddCalculator* createAddCalculator() {
		return new AddCalculatorA;
	}
	virtual SubCalculator* createSubCalculator() {
		return new SubCalculatorA;
	}	
};
class CalculatorBFactory :public CalculatorAbstractFactory {
public:
	virtual AddCalculator* createAddCalculator() {
		return new AddCalculatorB;
	}
	virtual SubCalculator* createSubCalculator() {
		return new SubCalculatorB;
	}	
};


void test01(float num1, float num2, char cType) {

	switch (cType)
	{
	case 'A':
	{
		CalculatorAbstractFactory* calA = new CalculatorAFactory;
		AddCalculator* addcal = calA->createAddCalculator();
		SubCalculator* subcal = calA->createSubCalculator();
		cout << addcal->getResult(num1, num2) << endl;
		cout << subcal->getResult(num1, num2) << endl;
		break;
	}		
	case 'B':
	{
		CalculatorAbstractFactory* calB = new CalculatorBFactory;
		cout << calB->createAddCalculator()->getResult(num1, num2) << endl;
		cout << calB->createSubCalculator()->getResult(num1, num2) << endl;
		break;
	}
	default:
		break;
	}
	
}

//***********************************//
int main() {
	try {
		float numberA;
		cout << "请输入数字A：";
		cin >> numberA;

		char cType;
		cout << "请选择计算器（A 或 B）：";
		cin >> cType;

		float numberB;
		cout << "请输入数字B：";
		cin >> numberB;

		test01(numberA, numberB, cType);
	}
	catch (const char* error) {   //注意这里是 char 类型
		cout << error << endl;
	}

	return 0;
}
大话设计模式 —— 第八章《工厂方法模式》C++ 代码实现
TAOTAO
04-01 378
目录 前言 工厂方法模式定义 优点 缺点 适合情景 前言 在本书的第一章的简单工厂模式，发现简单工厂模式存在一系列问题： 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响； 违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，那样就需要工厂类中做判断（比如：if），根据不同的条件或者前提创建不同的对象。这也就造成了，当增加新...
大话设计模式C++版——工厂方法模式
最新发布
m0_70960708的博客
10-07 757
工厂接口 IOperationFactory 提供一个生产 IOperation 计算对象的接口，然后不同的工厂对象生产不同IOperation 计算对象（加法工厂 COperationFactory_Add 生产 COperation_Add 对象，减法工厂 COperationFactory_Dec 则生产 COperation_Dec对象），即每一个生产对象对应一个工厂类，一个工厂类只生产一种产品，如五粮液只生产白酒，而青岛啤酒则只生产啤酒。我们仍以简单工厂模式中加减法计算器为例。
大话设计模式(一)简单工厂模式
热门推荐
IT全栈 华强工作室
04-12 5万+
今天主要设计简单工厂模式即静态工厂设计模式与工厂模式即抽象模式。 其中，简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建 其他类的实例，被创建的实例通常都具有共同的父类。 简单工厂模式中包含的角色及其职责： 1.工厂（Creator）角色 简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调 用，创建所需的产品对象。 2
大话设计模式（一）——简单工厂模式
不骄不躁，磨砥刻厉
02-15 566
文章目录一、前言二、概述三、演变过程四、优缺点及使用场景 一、前言     前段时间阅读了程杰的《大话设计模式》一书，在不缺乏趣味的同时，学习了如何思考设计模式。现在，笔者打算开启一个设计模式专栏，把自己的所感所悟写下来，以供日后重温。 如果想成为一名优秀的软件设计师，了解优秀软件设计的演变过程比学习优秀软件本身更有价值，因为设计的演变过程中蕴含大智慧。     正如本书作者所说，学习设计模式...
《大话设计模式》之简单的工厂模式
Smile&搁浅
12-23 729
面向对象 面向对象:可维护、可复用、可扩展、灵活性好 降低程序的耦合度：封装、继承、多态 设计模式：使程序更加灵活，容易修改，并且易于复用 业务的封装：将业务逻辑和界面逻辑分开，降低它们的耦合度 紧耦合和松耦合：封装、继承、多态可以降低耦合度 面向对象实例——加减乘除运算 运算类：运算数据、运算结果（virtual） 运算类的继承：加法类、减法类、乘法类、除法类 简单工厂类：实例化
大话设计模式一：简单工厂模式
进击的小怪兽
09-02 519
一.模式定义 简单工厂模式也称为静态工厂模式。属于类创建型设计模式。实质是一个“”工厂系统“”可以产生出多种不同的”产品对象”，使用者不需要知道“”产品对象“”是怎么产生的，只需要知道关于该“产品对象”的关键参数，将该参数传给“工厂系统”就可以由工厂系统生产出对应的产品。 二.模式要素 1.具体工厂：简单工厂模式的核心，负责实现创建所有具体产品类的实例。工厂类可以被外界直接调用来创建所...
大话设计模式—工厂模式
lmb55的专栏
05-31 2715
一、简介工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类： 简单工厂模式(Simple Factory) 工厂方法模式(Factory Method) 抽象工厂模式(Abstract Factory) 这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。下面是使用工厂模式的两种情况：1.在编码
Android之大话设计模式——：抽象工厂模式借鉴.pdf
12-25
Android之大话设计模式——：抽象工厂模式借鉴.pdf
Android之大话设计模式——：抽象工厂模式参考.pdf
12-01
Android之大话设计模式——：抽象工厂模式参考.pdf
大话设计模式 —— 第一章《简单工厂模式》C++代码实现
TAOTAO
03-15 468
简介 简单工厂模式（Simple Factory Pattern）属于类的创建型模式（但是简单工厂模式不属于23种设计模式之一），又叫静态工厂方法模式（Static FactoryMethod Pattern）, 是通过专门定义一个类来负责创建其他类的实例，这个类可以根据不同变量返回不同类的产品实例。被创建的实例通常都具有共同的基类。 ProductA、ProductB 和 Prod...
大话设计模式-简单工厂模式
weixin_34150503的博客
12-13 112
　　基本简介:从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 　　优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定...
大话设计模式——简单工厂模式
不见长安见晨雾
04-05 591
面向过程 需求：使用Java实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。 1）简单实现 public static void version1() { Scanner scanner = new Scanner(System.in); System.out.println("请输入数字A："); int A = scanner.nextInt(); System.out.println("请输入数字B：");
大话设计模式之--简单工厂模式
panther的专栏
08-29 748
文章开始借用大话设计模式中的例子说一下面向对象的思维。       “话说三国时期，曹操令百万大军攻打东吴，曹操说了一句：“喝酒唱歌，人生真爽”，一臣子为了拍马屁命令工匠刻板印刷，以便名流青史， 样张拿出来，曹操一看，不妥，当即改成对酒当歌，接着工匠连夜改版，只得全部重新改来，改完之后，曹操一看，感觉人生真爽太过直接，改为人生几何，接着工匠又要全部 改之。。。。。”        问题出在
《大话设计模式》——1.简单工厂设计模式
weixin_43487532的博客
01-28 612
简单工厂模式——计算器实现
大话设计模式-工厂模式
每天一个前端小知识~
07-13 4487
工厂模式 Spring IOC就是使用了工厂模式，对象的创建交给一个工厂去创建。 概念：工厂模式（Factory Pattern）使用一个共同的接口指向新创建的对象。 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类 主要解决：解决接口的选择问题 何时使用：不同条件创建不同实例时 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品 关键点：创建过程在其子类执行 应用实例：当你需要一辆汽车，可以直接去工厂提货，而不用管这辆车是怎们做出来的，以及汽车里面的具体实现 优点： 1.调用者创建对
大话设计模式-三种工厂模式（简单工厂、工厂方法、抽象工厂）
向诸位大佬虚心学习
12-25 535
工厂模式 有三种：简单工厂模式，工厂方法模式，抽象工厂模式
【大话设计模式】工厂方法模式
_
08-31 214
工厂方法模式
大话设计模式之一【简单工厂模式】
simeth的专栏
07-06 326
<br />这章简单工厂模式主要以一个简单的计算器为例来演示，多的不说直接上代码<br /> <br /> <br />首先是 OperationLibrary 类库 的代码<br /> <br /> using System; using System.Collections.Generic; using System.Text; namespace OperationLibrary { /// <summary> /// 运算类 /// </summary>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值