C++设计模式——工厂方法模式和抽象工厂方法模式

一、工厂方法模式
上面的简单工厂模式的缺点是当新增产品的时候就要去修改工厂的类，这就违反了开放封闭原则，(类、模块、函数)可以扩展，但是不可以修改，于是，就出现了工厂方法模式。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

//抽象的水果类
class Fruit
{
public:
	virtual void getName() = 0;
};

class Apple :public Fruit {
public:
	virtual void getName() {
		cout << "我是苹果" << endl;
	}
};

class Banana :public Fruit {
public:
	virtual void getName() {
		cout << "我是香蕉 " << endl;
	}
};

//添加一个梨产品
class Pear : public Fruit
{
public:
	virtual void getName() {
		cout << "我是鸭梨 " << endl;
	}
};

//抽象的工厂类
class AbstractFactory
{
public:
	virtual Fruit * createFruit() = 0;//抽象的水果生产器
};

//苹果的工厂
class AppleFactory :public AbstractFactory
{
public:
	virtual Fruit * createFruit() {
		return new Apple;
	}
};

//香蕉工厂 
class BananaFactory : public AbstractFactory {
public:
	virtual Fruit *createFruit() {
		return new Banana;
	}
};

//添加梨的工厂
class PearFactory :public AbstractFactory
{
public:
	virtual Fruit *createFruit() {
		return  new Pear;
	}
};

int main(void)
{
	//1 给我来一个香蕉的工厂
	AbstractFactory * bananaFactory = new BananaFactory;
	//2 给我来一个水果
	Fruit * banana = bananaFactory->createFruit(); //只能够生成香蕉 //多态
	//Fruit *banana = new Banana;
	banana->getName(); //多态

	delete bananaFactory;
	delete banana;

	AbstractFactory *appleFactory = new AppleFactory;
	Fruit *apple = appleFactory->createFruit();
	apple->getName();

	AbstractFactory *pearFactory = new PearFactory;
	Fruit *pear = pearFactory->createFruit();
	//Fruit *pear = new Pear;
	pear->getName(); //多态
	
	return 0;
}

二、抽象工厂模式
为什么要有抽象工厂模式，假如我们A产品中有A1和A2两种型号的厂品，B产品中有B1和B2两种型号的厂品，那怎么办，上面两种工厂模式就不能解决了。这个时候抽象工厂模式就登场了。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。适用性：一个系统要独立于它的产品的创建、组合和表示时。一个系统要由多个产品系列中的一个来配置时。当你要强调一系列相关的产品对象的设计以便进行联合使用时。当你提供一个产品类库，而只想显示它们的接口而不是实现时。

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

//1 添加一个日本的工厂 和日本的苹果 和 香蕉  (添加一个产品族)
//针对产品族进行添加 符合开闭

//2 添加一个产品种类， 鸭梨  (添加一个产品等级结构)
//针对产品等级机构添加 不符合开闭

//3 考虑 1， 2  是否都符合开闭原则

class Fruit
{
public:
	virtual void getName() = 0;
};

class USAApple :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是美国的苹果" << endl;
	}
};
class USABanana :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是美国的香蕉" << endl;
	}
};

class USAPear :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是美国的梨" << endl;
	}
};
class ChinaApple :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是中国的苹果" << endl;
	}
};

class ChinaBanana :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是中国的香蕉" << endl;
	}
};

class ChinaPear :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是中国的梨" << endl;
	}
};

//顶一个一个抽象的工厂，是面向产品族进行生产
class AbstractFactory {
public:
	virtual Fruit *createApple() = 0;
	virtual Fruit *createBanana() = 0;
	//添加一个鸭梨的生成器
	virtual Fruit* createPear() = 0;
};
//美国的具体工厂
class USAFactory :public AbstractFactory
{
public:
	virtual Fruit *createApple() {
		return new USAApple;
	}
	virtual Fruit *createBanana()  {
		return new USABanana;
	}

	//添加一个美国的生产器
	virtual Fruit * createPear() {
		return new USAPear;
	}
};

//中国的工厂
class ChinaFactory :public AbstractFactory
{
public:
	virtual Fruit *createApple()
	{
		return new ChinaApple;
	}

	virtual Fruit *createBanana()  {
		return new ChinaBanana;
	}

	//添加一个的生产器
	virtual Fruit * createPear() {
		return new ChinaPear;
	}
};

//添加一个日本的产品族，工厂，和具体产品  符合 开闭原则
class JapanApple :public Fruit
{
public:
	virtual void getName() {
		cout << "我是日本的苹果" << endl;
	}
};

class JapanBanana :public Fruit
{
public:
	virtual void getName() {
		cout << "我是日本的香蕉" << endl;
	}
};

class JapanPear :public Fruit
{
public:
	virtual void getName()  {
		cout << "我是日本的梨" << endl;
	}
};


class JapanFactory :public AbstractFactory
{
public:
	virtual Fruit *createApple() {
		return new JapanApple;
	}
	virtual Fruit *createBanana()  {
		return new JapanBanana;
	}

	virtual Fruit * createPear() {
		return new JapanPear;
	}
};

int main(void)
{
	//想要一个美国的香蕉
	//1 来一个美国的工厂
	AbstractFactory * usaF = new USAFactory;
	//2 来一个香蕉
	Fruit *usaBanana = usaF->createBanana();

	usaBanana->getName();


	//想要一个中国的苹果
	AbstractFactory *chinaF = new ChinaFactory;
	Fruit *chinaApple = chinaF->createApple();

	chinaApple->getName();
	
	return 0;
}

抽象工厂模式练习

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

// 0---------  抽象层 ------
class CPU
{
public:
	virtual void caculate() = 0; 
};

class Card
{
public:
	virtual void display() = 0;
};

class Memory
{
public:
	virtual void storage() = 0;
};

class AbstractFactory
{
public:
	virtual CPU* createCPU() = 0;
	virtual Card* createCard() = 0;
	virtual Memory * createMem() = 0;
};

//架构类
class Computer
{
public:
	Computer(CPU *cpu, Card *card, Memory *mem)
	{
		this->cpu = cpu;
		this->card = card;
		this->mem = mem;
	}

	void work() {
		this->cpu->caculate();
		this->card->display();
		this->mem->storage();
	}
private:
	CPU *cpu;
	Card*card;
	Memory *mem;
};

//抽象层结束------

// ----- 实现层-----
//intel厂商
class IntelCPU :public CPU
{
public:
	virtual void caculate() {
		cout << "Intel CPU 开始计算了..." << endl;
	}
};

class IntelCard :public Card
{
public:
	virtual void display() {
		cout << "Intel card 开始显示 了..." << endl;
	}
};

class IntelMem :public Memory
{
public:
	virtual void storage() {
		cout << "Intel mem 开始存储了..." << endl;
	}
};

class IntelFactory :public AbstractFactory
{
public:
	virtual CPU* createCPU()  {
		return new IntelCPU;
	}
	virtual Card* createCard() {
		return new IntelCard;
	}
	virtual Memory * createMem()  {
		return new IntelMem;
	}
};

// NVIDIA的厂商

class NvidiaCPU :public CPU
{
public:
	virtual void caculate() {
		cout << "Nvidia CPU 开始计算了..." << endl;
	}
};

class NvidiaCard :public Card
{
public:
	virtual void display() {
		cout << "Nvidia card 开始显示 了..." << endl;
	}
};

class NvidiaMem :public Memory
{
public:
	virtual void storage() {
		cout << "Nvidia mem 开始存储了..." << endl;
	}
};

class NvidiaFacory :public AbstractFactory
{
public:
	virtual CPU* createCPU()  {
		return new NvidiaCPU;
	}
	virtual Card* createCard() {
		return new NvidiaCard;
	}
	virtual Memory * createMem()  {
		return new NvidiaMem;
	}
};


// Kinston 厂商

class KinstonCPU :public CPU
{
public:
	virtual void caculate() {
		cout << "Kinston CPU 开始计算了..." << endl;
	}
};

class KinstonCard :public Card
{
public:
	virtual void display() {
		cout << "Kinston card 开始显示 了..." << endl;
	}
};

class KinstonMem :public Memory
{
public:
	virtual void storage() {
		cout << "Kinston mem 开始存储了..." << endl;
	}
};

class KinstonFacory :public AbstractFactory
{
public:
	virtual CPU* createCPU()  {
		return new KinstonCPU;
	}
	virtual Card* createCard() {
		return new KinstonCard;
	}
	virtual Memory * createMem()  {
		return new KinstonMem;
	}
};

int main(void)
{
	//1 组装一个intel系列的电脑 对intel公司的所有产品，执行一个单元测试。
	//创建一个intel的工厂
	AbstractFactory * intelFactory = new IntelFactory;
	CPU *intelCPU = intelFactory->createCPU();
	Card *intelCard = intelFactory->createCard();
	Memory *intelMem = intelFactory->createMem();

	Computer *com1 = new Computer(intelCPU, intelCard, intelMem);
	com1->work();


	cout << " -----  " << endl;

	//2 组装一个 intel的cpu  kinston card  NVIDIA的显卡的电脑
	AbstractFactory *kinstonFactory = new KinstonFacory;
	Memory *kingstonMem = kinstonFactory->createMem();
	AbstractFactory *nvidiaFactory = new NvidiaFacory;
	Card *nvidiaCard = nvidiaFactory->createCard();

	Computer *com2 = new Computer(intelCPU, nvidiaCard, kingstonMem);
	com2->work();


	return 0;
}

C++设计模式——工厂方法模式和抽象工厂方法模式

猜你喜欢