学习【设计模式】从简单开始----------------三种工厂模式

工厂模式（创建型）

说明：工厂模式分为三种：简单工厂、工厂模式、抽象工厂模式。

1、工厂模式（类图如下）

解释：工厂模式其实就是把类的创建封装起来，代码如下。

#include<iostream>
using namespace std;

class Product{				//目标产品类 
public:
	virtual void Do() = 0;
		
	virtual ~Product() {		//虚化父类析构为了让派生类对象完全释放
		cout<<"总析构"<<endl;
	}
};

class ProductA:public Product{
	void Do() {
		cout<<"给，西红柿炒鸡蛋"<<endl;
	}
	
	~ProductA() {
		cout<<"A的析构"<<endl;
	}
};


class ProductB:public Product{
	void Do() {
		cout<<"给，青菜炒蘑菇"<<endl;
	}
	
	~ProductB() {
		cout<<"B的析构"<<endl;
	}
};

class ProductC:public Product{
	void Do() {
		cout<<"给，紫菜蛋花汤"<<endl;
	}
	
	~ProductC() {
		cout<<"C的析构"<<endl;
	}
};

class Factory{
private:
	Product* product;
public:
	Factory(int n) {		//在工厂里边进行加工，准备生产产品 
		switch(n){
			case 1:
				product = new ProductA();break;
			case 2:
				product = new ProductB();break;
			case 3:
				product = new ProductC();break;
		}
	}
		
	void send() {
		product->Do();
	
	}
		
	~Factory() {
		cout<<"Factory 的析构"<<endl;
		delete product;
	}
};

int main() {
	//客户端可以根据已有的菜单的索引号来选择生产那种产品 
	Factory* factory = new Factory(1);
	factory->send();
	delete factory;
	
	return 0; 
}

2、工厂模式（类图和简单工厂一样）

解释：简化了switch case的过程。

#include<iostream>
using namespace std;

class Product{
public:
	virtual void Do() = 0;
		
	virtual ~Product() {
		cout<<"Product总析构"<<endl;
	}
};

class ProductA:public Product{
	void Do() {
		cout<<"给，西红柿炒鸡蛋"<<endl;
	}
	
	~ProductA() {
		cout<<"A的析构"<<endl;
	}
};

class ProductB:public Product{
	void Do() {
		cout<<"给，青菜炒蘑菇"<<endl;
	}
	
	~ProductB() {
		cout<<"B的析构"<<endl;
	}
};

class ProductC:public Product{
	void Do() {
		cout<<"给，紫菜蛋花汤"<<endl;
	}
	
	~ProductC() {
		cout<<"C的析构"<<endl;
	}
};

class Factory{
private:
	Product* product;
public:
	Factory(Product* t) {
		product = t;
	}
	//简化了switch case的过程，让父类指针直接戳到主动调用的派生类对象的方法 
		/*Factory(int n) {
			switch(n){
				case 1:
					product = new ProductA();
				case 2:
					product = new ProductB();
				case 3:
					product = new ProductC();
			}
		}
		*/
		void send() {
			product->Do();
		}
		
		~Factory() {
			cout<<"Factory 的析构"<<endl;
			delete product;
		}
};

int main() {
	Factory* factory = new Factory(new ProductA());
	factory->send();
	delete factory;
	
	return 0;
}

3、抽象工厂（类图如下）

设计原则：

（1）开闭原则

（2）高内聚，低耦合

（3）提高软件可重用性

解释：简单工厂与工厂违背了开闭原则，所以让Factory派生出相应的类。（代码如下）：

#include<iostream>
using namespace std;

class Product{
public:
	virtual void Do() = 0;
		
	virtual ~Product() {
		cout<<"总析构"<<endl;
	}
};

class ProductA:public Product{
	void Do() {
		cout<<"给，西红柿炒鸡蛋"<<endl;
	}
	
	~ProductA() {
		cout<<"A的析构"<<endl;
	}
};

class ProductB:public Product{
	void Do() {
		cout<<"给，青菜炒蘑菇"<<endl;
	}
	
	~ProductB() {
		cout<<"B的析构"<<endl;
	}
};

class ProductC:public Product{
	void Do() {
		cout<<"给，紫菜蛋花汤"<<endl;
	}
	
	~ProductC() {
		cout<<"C的析构"<<endl;
	}
};

class Factory{
	//改为受保护 
protected:
	Product* product;
public:
		
		/*Factory(int n) {
			switch(n){
				case 1:
					product = new ProductA();
				case 2:
					product = new ProductB();
				case 3:
					product = new ProductC();
			}
		}*/
		
	virtual void send() = 0;
		/*void send() {
			product->Do();
		}*/
		
	virtual ~Factory() {
		cout<<"Factory 的析构"<<endl;
		delete product;
	}
};
class FactoryA:public Factory{
public:
	FactoryA(Product* A) {
		product = A;
	}
		
	void send() {
		product->Do();
	}
		
	~FactoryA() {
		cout<<"FA的析构"<<endl;
	}
}; 

class FactoryC:public Factory{
public:
	FactoryC(Product* C) {
		product = C;
	}
		
	void send() {
		product->Do();
	}
		
	~FactoryC() {
		cout<<"FC的析构"<<endl;
	}
};

class FactoryB:public Factory{	
public:
	FactoryB(Product* B) {
		product = B;
	}
		
	void send() {
		product->Do();
	}
	
	~FactoryB() {
		cout<<"FB的析构"<<endl;
	}
};
//让Factory也拥有众多与Product相对应的派生类，
//将send方法进行虚化，从而降低耦合度 
int main() {
	Factory* factory = new FactoryA(new ProductA());
	factory->send();
	delete factory;
	
	return 0;
}

笔者在学习中想积累点经验，所以编辑博客让自己对知识进行进一步的认知和强化，希望大家共同探讨，共同进步！有什么问题或者什么错误尽管留言！