_004_工厂设计模式_抽象工厂设计模式

=======================================

一 工厂设计模式

1 独立出工厂,然后再由工厂创建生成器,再由生成器创建水果

我们如果想要香蕉,那么直接创建了一个香蕉工厂

比如 "工厂 *gc=new 香蕉工厂" ,然后由工厂创建出生成器,再由生

产器去创建水果,注意这个生成器应该是一个函数,在香蕉工厂内的函

数,而不是一个类,具体看如下代码

2 工厂的4个角色

3 工厂设计模式代码

#include <iostream>

using namespace std;

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

//具体的苹果类去继承并重写Fruits
class Apple :public Fruits
{
public:
	virtual void getName()
	{
		cout << "苹果" << endl;
	}
};

//具体的梨子类去继承并重写Fruits
class Pear :public Fruits
{
public:
	virtual void getName()
	{
		cout << "梨子" << endl;
	}
};

//抽象一个水果工厂
class Fruits_Factory
{
public:
	virtual Fruits* create_Fruits() = 0;
};

//具体的苹果工厂类去继承并重写Fruits_Factory
class Apple_Factory :public Fruits_Factory
{
public:

	//关键是这里 create_Fruits就是一个生成器,这个create_Fruits应该有返回值,就是返回水果的对象
	virtual Fruits* create_Fruits()
	{
		return  new Apple;
	}
};

class Pear_Factory :public Fruits_Factory
{
public:
	virtual Fruits* create_Fruits()
	{
		return new Pear;
	}
};

int main()
{
	//创建一个苹果工厂,苹果工厂里面有一个生成器的方法,这个方法返回的是一个苹果
	//苹果是水果,直接用水果来接受,苹果继承水果,然后重写水果的方式,就可以做到,不管是什么水果
	//只要调用getName就能实现功能,方便了很多
	Fruits_Factory *ff1 = new Apple_Factory;
	Fruits* f1=ff1->create_Fruits();
	f1->getName();

	//如果我们想加一个梨子,那么添加一个梨子类继承水果并重写其方法
	//然后写一个梨子生成器类去继承工厂类,重写其方法,即可添加一个梨子,不必修改源代码,符合开闭原则
	Fruits_Factory *ff2 = new Pear_Factory;
	Fruits* f2 = ff2->create_Fruits();
	f2->getName();

}

=======================================

二 抽象工厂设计模式

1 如果一系列的产品,他们都来自同一个产商,需要实现固定的功能

那么这就是一个产品族

2 如果一系列产品,他们来自不同的产商,需要实现固定的功能,那么这

就是一个产品等级结构

3 抽象工厂设计模式代码和其概念

   

#include <iostream>
using namespace std;


//创建一个抽象的水果类
class Fruits
{
public:
	virtual void getName() = 0;
};


//美国的苹果
class USA_Apple :public Fruits
{
public:
	void getName()
	{
		cout << "USA_Apple功能" << endl;
	}
};


//美国的梨子
class USA_Pear :public Fruits
{
public:
	void getName()
	{
		cout << "USA_Pear功能" << endl;
	}
};


//中国的苹果
class China_Apple :public Fruits
{
public:
	void getName()
	{
		cout << "China_Apple功能" << endl;
	}
};


//中国的梨子
class China_Pear :public Fruits
{
public:
	void getName()
	{
		cout << "China_Pear功能" << endl;
	}
};


//抽象一个工厂类
class Fatcory
{
public:
	virtual  Fruits * create_Apple() = 0;
	virtual  Fruits * create_Pear() = 0;
};


//创建一个美国的工厂用来生成美国的水果
class USA_Fatcory:public Fatcory
{
public:
	virtual Fruits *create_Apple()
	{
		return new USA_Apple;
	}


	virtual Fruits * create_Pear()
	{
		return new USA_Pear;
	}
};


//创建一个中国的工厂用来生成中国的水果
class China_Fatcory :public Fatcory
{
public:
	virtual Fruits *create_Apple()
	{
		return new China_Apple;
	}


	virtual Fruits * create_Pear()
	{
		return new China_Pear;
	}
};




int main()
{
	//先创建一个美国的工厂,再由美国的苹果生产器获得美国的水果
	Fatcory *fa = new USA_Fatcory;
	Fruits *usa_ap1=fa->create_Apple();
	usa_ap1->getName();


	//如果我们现在需要加入一个中国的产地,那么只需要再创建一个中国的工厂去继承并实现工厂类
	//然后创建一个苹果类继承并实现水果类即可,但是有一个前提,那就是 Fatcory里面有支持能够生产
	//苹果类的虚函数,这样我们创建的工厂才能去实现生产苹果
	Fatcory *fa2 = new China_Fatcory;
	Fruits *usa_ap2 = fa2->create_Apple();
	usa_ap2->getName();


	//在Fatcory里面有支持能够生产苹果类的接口前提下,我们创建一个中国的产地,生产中国的apple和pear
	//这叫创建一个产品族


	//而如果Fatcory没有能够生产苹果类的虚函数,那我们就需要在Fatcory里面写一个create_apple的虚函数
	//这叫创建产品等级结构


	//但是这就出现了一个弊端,那就是如果在Fatcory写一个虚函数,那么China_Fatcory和USA_Fatcory
	//都需要写create_apple函数,USA_Fatcory这就修改类了,不符合开闭原则


	//所以抽象工厂设计模式是在确定了产品等级结构(哪些产品)之后才会用这个模式
	
	//而工厂设计模式,比抽象工厂设计模式低一个层次,没有考虑产地问题,也就是来源的问题
	//直接就是水果工厂,然后用具体的水果去继承并实现水果工厂
	
	// 假如我们需要生产一些产品,比如主板,主板上面有3大固件,cpu,内存,显卡
	// 而A,B,C 3个产商均会生产上面3个固件
	//现在需要组装1个主板 a的cpu,b的内存,c的显卡

	/*
	创建一个创建抽象固件类,里面只有一个接口, virtual void 功能()=0 
	 然后创建a的cpu类,a的显卡类,a的内存类去继承并实现抽象固件类,b和c仿照如此
	创建一个抽象工厂类,里面有3个接口,分别是创建cpu,创建内存,创建显卡,
	 然后创建a工厂类,b工厂类,c工厂类,并且都继承工厂类,实现工厂类的函数
	这个函数的返回值就是抽象固件类,函数里就只有一条代码,return new a的cpu类;


        抽象工厂类 *c1=new a工厂;
       固件类 *m1=c1->创建a的cpu类();
       m1->功能();
	*/
	
}

4 抽象工厂设计模式和工厂设计模式的适用范围

工厂设计模式,比抽象工厂设计模式低一个层次,不需要考虑来源

抽象工厂设计模式是在项目比较大,要联合很多产商的情况下才会使

   用,一般是使用工厂设计模式就够了