设计模式--工厂模式

Zhang丶&｜！

已于 2023-08-03 16:12:34 修改

阅读量260

点赞数 1

分类专栏： C/C++学习笔记文章标签： c++ 开发语言

于 2023-08-01 10:59:54 首次发布

本文链接：https://blog.csdn.net/qq_57594025/article/details/132034320

版权

C/C++学习笔记专栏收录该内容

41 篇文章 2 订阅

订阅专栏

一、简单工厂模式

1、理论

1.1 优点

①客户端和具体实现类解耦。

②对于某些创建对象过程复杂的类，我们也不用考虑。

1.2 缺点

①增加功能需要修改工厂类源码，不符合开闭原则（一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。）。

②工厂类职责过重，如果这个类发生问题，会影响很多使用这个工厂的模块

2、代码

#include <iostream>
using namespace std;

//抽象水果
class AbstractFruit
{
public:
	virtual void ShowName() = 0;
};

//具体水果1
class Apple: public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Apple!" << endl;
	}
};

//具体水果2
class Banana : public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Banana!" << endl;
	}
};

//具体水果3
class Pear : public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Pear!" << endl;
	}
};

//工厂类
class FruitFactory
{
public:
	static AbstractFruit* CreateFruit(string flag)
	{
		if (flag == "Apple")
		{
			//创建复杂对象相关操作...
			return new Apple;
		}
		else if (flag== "Banana")
		{
			//创建复杂对象相关操作...
			return new Banana;
		}
		else if (flag == "Pear")
		{
			//创建复杂对象相关操作...
			return new Pear;
		}
		else
		{
			return nullptr;
		}
	}
};

void test01(void)
{
	//创建工厂，通过工厂来创建对象
	FruitFactory* factory = new FruitFactory;
	AbstractFruit* fruit = factory->CreateFruit("Apple");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("Banana");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("Pear");
	fruit->ShowName();
	delete fruit;

	delete factory;
}

int main(int argc, char *argv[])
{
	test01();
	system("pause");
	return 0;
}

二、工厂方法模式

1、理论

①简单工厂模式+“开闭原则”=工厂方法模式

②为解决简单工厂模式工厂类不符合开闭原则的问题，为每个具体类都实现一个对应的工厂类，导致一个新问题，类的数量越来越多，增加维护成本。

1.1 优点

①不需要记住具体类名，甚至连具体参数都不需要记忆。

②实现了对象创建和使用的分离。

③系统的可扩展性也就变得非常好，无需修改接口和原类。

1.2 缺点

①增加系统中类的个数，复杂度和理解难度增加。

②增加了系统的抽象性和理解难度。

2、代码

#include <iostream>
using namespace std;

//抽象水果
class AbstractFruit
{
public:
	virtual void ShowName() = 0;
};

//具体水果1
class Apple: public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Apple!" << endl;
	}
};

//具体水果2
class Banana : public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Banana!" << endl;
	}
};

//具体水果3
class Pear : public AbstractFruit
{
public:
	virtual void ShowName()
	{
		cout << "I am Pear!" << endl;
	}
};

//抽象水果工厂
class AbstractFruitFactory
{
public:
	virtual AbstractFruit* CreateFruit() = 0;
};

//具体水果工厂1
class AppleFactory :public AbstractFruitFactory
{
public:
	virtual AbstractFruit* CreateFruit()
	{
		//其它操作...
		return new Apple;
	}
};

//具体水果工厂2
class BananaFactory :public AbstractFruitFactory
{
public:
	virtual AbstractFruit* CreateFruit()
	{
		//其它操作...
		return new Banana;
	}
};

//具体水果工厂3
class PearFactory :public AbstractFruitFactory
{
public:
	virtual AbstractFruit* CreateFruit()
	{
		//其它操作...
		return new Pear;
	}
};

void test01(void)
{
	AbstractFruitFactory* factory = nullptr;//水果工厂
	AbstractFruit* fruit = nullptr;//水果
	
	//创建苹果工厂
	factory = new AppleFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	factory = new BananaFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	factory = new PearFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;
}

int main(int argc, char *argv[])
{
	test01();
	system("pause");
	return 0;
}

三、简单工厂与工厂方法模式适用场景

1、简单工厂适用场景

①工厂类负责创建的对象比较少，由于创建的对象较少。不会造成工厂方法中的业务逻辑太过复杂。

②客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

2、工厂方法适用场景

①客户端不知道它所需要的对象的类。

②抽象工厂类通过其子类来指定创建哪个对象。

四、抽象工厂模式

1、理论

抽象工厂针对的是产品族，而不是产品等级结构

①产品族：同一产地或同一厂商，功能不同

②产品等级：功能相同，产地或者厂商不同。

2、代码

#include <iostream>
using namespace std;

//抽象苹果
class AbstractApple
{
public:
	virtual void ShowName() = 0;
};

//抽象香蕉
class AbstractBanana
{
public:
	virtual void ShowName() = 0;
};

//抽象梨
class AbstractPear
{
public:
	virtual void ShowName() = 0;
};

//中国苹果
class ChinaApple :public AbstractApple
{
public:
	virtual void ShowName()
	{
		cout << "I am ChinaApple" << endl;
	}
};

//美国苹果
class USAApple :public AbstractApple
{
public:
	virtual void ShowName()
	{
		cout << "I am USAApple" << endl;
	}
};

//日本苹果
class JapanApple :public AbstractApple
{
public:
	virtual void ShowName()
	{
		cout << "I am JapanApple" << endl;
	}
};

//中国香蕉
class ChinaBanana :public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "I am ChinaBanana" << endl;
	}
};

//美国香蕉
class USAABanana :public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "I am USABanana" << endl;
	}
};

//日本香蕉
class JapanBanana :public AbstractBanana
{
public:
	virtual void ShowName()
	{
		cout << "I am JapanBanana" << endl;
	}
};

//中国梨
class ChinaPear :public AbstractPear
{
public:
	virtual void ShowName()
	{
		cout << "I am ChinaPear" << endl;
	}
};

//美国梨
class USAAPear :public AbstractPear
{
public:
	virtual void ShowName()
	{
		cout << "I am USAPear" << endl;
	}
};

//日本梨
class JapanPear :public AbstractPear
{
public:
	virtual void ShowName()
	{
		cout << "I am JapanPear" << endl;
	}
};

//抽象工厂--针对产品族
class AbstractFactory
{
public:
	virtual AbstractApple* CreatApple() = 0;
	virtual AbstractBanana* CreatBanana() = 0;
	virtual AbstractPear* CreatPear() = 0;
};

//中国工厂
class ChinaFactory :public AbstractFactory
{
public:
	virtual AbstractApple* CreatApple()
	{
		return new ChinaApple;
	}
	virtual AbstractBanana* CreatBanana()
	{
		return new ChinaBanana;
	}
	virtual AbstractPear* CreatPear()
	{
		return new ChinaPear;
	}
};

//美国工厂
class USAFactory :public AbstractFactory
{
public:
	virtual AbstractApple* CreatApple()
	{
		return new USAApple;
	}
	virtual AbstractBanana* CreatBanana()
	{
		return new USAABanana;
	}
	virtual AbstractPear* CreatPear()
	{
		return new USAAPear;
	}
};

//日本工厂
class JapanFactory :public AbstractFactory
{
public:
	virtual AbstractApple* CreatApple()
	{
		return new JapanApple;
	}
	virtual AbstractBanana* CreatBanana()
	{
		return new JapanBanana;
	}
	virtual AbstractPear* CreatPear()
	{
		return new JapanPear;
	}
};

void test01(void)
{
	AbstractFactory* factory = nullptr;
	AbstractApple* apple = nullptr;
	AbstractBanana* banana = nullptr;
	AbstractPear* pear = nullptr;

	//中国工厂
	factory = new ChinaFactory;
	apple = factory->CreatApple();
	banana = factory->CreatBanana();
	pear = factory->CreatPear();
	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
	delete apple;
	delete banana;
	delete pear;
	delete factory;

	//美国工厂
	factory = new USAFactory;
	apple = factory->CreatApple();
	banana = factory->CreatBanana();
	pear = factory->CreatPear();
	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
	delete apple;
	delete banana;
	delete pear;
	delete factory;

	//日本工厂
	factory = new JapanFactory;
	apple = factory->CreatApple();
	banana = factory->CreatBanana();
	pear = factory->CreatPear();
	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
	delete apple;
	delete banana;
	delete pear;
	delete factory;
}

int main(int argc, char *argv[])
{
	test01();
	system("pause");
	return 0;
}