【设计模式】工厂模式：简单工厂、工厂、抽象工厂

概念

工厂模式是一种创建型模式，即一个类用于创建其他类的实例，被创建的类的实例通常拥有共同的父类。

1.简单工厂

角色

• 一个工厂类，负责创建具体产品类的实例。
• 一个抽象的产品类，是所有具体产品类的父类。
• 若干个具体产品类。

优缺点

优点：
本着高内聚低耦合的原则，将系统的逻辑部分和功能分开
缺点：
增加系统类的个数，从而增加系统复杂度。
工厂职责重，影响系统灵活性和扩展性。

应用

需要创建的对象很多，对象的创建过程是不关心的。

代码实现

//simple factory
#include <iostream>
using namespace std;
class Product{
public:
	virtual ~Product(){};
protected:
	Product(){};
};

class A_Product:public Product{
public:
	A_Product(){
		cout<<"A_Product"<<endl;
	}
	~A_Product(){}
};

class B_Product:public Product{
public:
	B_Product(){
		cout<<"B_Product"<<endl;
	}
	~B_Product(){}
};

class Simple_Factory{
public:
	Simple_Factory(){
		cout<<"simple factory"<<endl;
	}
	Product* createA(){
		return new A_Product();
	}
	Product* createB(){
		return new B_Product();
	}
};


int main(){
	Simple_Factory *f=new Simple_Factory();
	f->createA();
	f->createB();
	return 0;
}

2.工厂

简介

在工厂模式中，工厂父类负责定义创建产品对象的公告接口，而工厂子类负责生成具体的产品对象。目的是将产品的实例化操作延迟到工厂子类中完成，通过工厂子类来确定究竟应该实例化哪一个具体产品类。

角色

• 一个抽象的工厂类，是其他具体工厂的父类。
• 若干个具体的工厂类，负责创建具体产品类的实例。
• 一个抽象的产品类，是其他具体产品类的父类
• 若干个具体产品类。

应用

设计初期就考虑到产品后期会进行扩展。
产品结构较复杂。

优缺点

优点
系统扩展性好，符合开闭原则。加入新产品时无需修改其他具体工厂类，只需添加一个具体工厂和具体产品。
缺点：
添加新产品时要提供与之对于的工厂，类的个数成对增加。

代码实现

//factory
#include<iostream>
using namespace std;

class Product{
public:	
	virtual ~Product(){}
protected:
	Product(){}
};

class ConcreteProduct:public Product{
public:
	ConcreteProduct(){
		cout<<"ConcreteProduct"<<endl;
	}
	~ConcreteProduct(){}
};

class Another_ConcreteProduct:public Product{
public:
	Another_ConcreteProduct(){
		cout<<"Another_ConcreteProduct"<<endl;
	}
	~Another_ConcreteProduct(){}
};




class Factory{
public:
	virtual ~Factory(){}
	virtual Product* CreateProduct()=0;
protected:
	Factory(){}

};

class ConcreteFactory:public Factory{
public:
	ConcreteFactory(){
		cout<<"ConcreteFactory"<<endl;
	}
	~ConcreteFactory(){}
	Product* CreateProduct(){
		return new ConcreteProduct();
	}
};

class Another_ConcreteFactory:public Factory{
public:
	Another_ConcreteFactory(){
		cout<<"Another_ConcreteFactory"<<endl;
	}
	~Another_ConcreteFactory(){}
	Product* CreateProduct(){
		return new Another_ConcreteProduct();
	}
};

int main(){
	Factory* f1=new ConcreteFactory();
	Factory* f2=new Another_ConcreteFactory();
	Product* p1=f1->CreateProduct();
	Product* p2=f2->CreateProduct();
	return 0;
}

3.抽象工厂

简介

抽象工厂模式是工厂方法模式的泛化版，工厂模式是一种特殊的抽象工厂模式，在工厂模式中，每个具体工厂只能生产一种具体的产品，而抽象工厂方法模式中，一个具体的工厂可以生产多个具体产品。

角色

• 一个抽象工厂类，提供每种抽象产品类实例的创建接口
• 若干个抽象产品类
• 若干个具体工厂类，不同的具体工厂实现不同的继承自其抽象产品类的具体产品类的实例。
• 若干个具体产品类，每个具体工厂的每种抽象产品各有一个具体产品类。

优缺点

优点

• 将产品族的依赖和约束关系放在抽象工厂中，便于管理。

• 切换产品族容易，只需增加一个具体工厂，选择另一套产品体系。

缺点

• 有一个产品族就需要增加一个具体工厂，类增加的速度很快。
• 产品族难以扩展产品，增加一个产品，抽象工厂增加一个接口，所有具体工厂都要修改。
• 没有完全屏蔽创建的细节，创建的都是组件。

应用

当需要创建的对象是一系列相互关联或相互依赖的产品族时

代码实现

//abstruct factory

#include<iostream>
using namespace std;

class TV{
};

class AC{
};

class Factory{
public:
	Factory(){};
	~Factory(){};
	virtual AC* create_AC()=0;
	virtual TV* create_TV()=0;
};


class Ford_TV:public TV{
public:
	Ford_TV(){
		cout<<"Ford_TV"<<endl;
	}
};

class Ford_AC:public AC{
public:
	Ford_AC(){
		cout<<"Ford_AC"<<endl;
	}
};

class Mex_TV:public TV{
public:
	Mex_TV(){
		cout<<"Mex_TV"<<endl;
	}
};

class Mex_AC:public AC{
public:
	Mex_AC(){
		cout<<"Mex_AC"<<endl;
	}
};

class Ford_Factory:public Factory{
public:
	Ford_Factory(){};
	TV* create_TV(){
		return new Ford_TV();
	}
	AC* create_AC(){
		return new Ford_AC();
	}
};

class Mex_Factory:public Factory{
public:
	Mex_Factory(){};
	TV* create_TV(){
		return new Mex_TV();
	}
	AC* create_AC(){
		return new Mex_AC();
	}
};


int main(){
	Factory* f1=new Ford_Factory();
	Factory* f2=new Mex_Factory();
	TV* tv1=f1->create_TV();
	TV* tv2=f2->create_TV();
	AC* ac1=f1->create_AC();
	AC* ac2=f2->create_AC();
	return 0;
}

参考自：参考