工厂模式
参考:https://www.cnblogs.com/huiz/p/8232783.html
1、简单工厂模式
在工厂类做判断,从而创建相应的产品,当增加产品时需要修改工厂类。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
//简单工厂模式
//枚举
enum cartype{benci,baoma};
//抽象类(多态:提高基类)
class car{
public:
virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
bencicar(){
cout<<" begin create bencicar "<<endl;
}
void createcar(void){
cout<<" creating bencicar "<<endl;
}
~bencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
baomacar(){
cout<<" begin create baomacar "<<endl;
}
void createcar(void){
cout<<" creating baomacar "<<endl;
}
~baomacar(){}
};
//工厂类
class carfactory{
public:
car* createSpecificCar(cartype type){
switch(type){
case benci:
return (new bencicar());
break;
case baoma:
return (new baomacar());
break;
default:
return NULL;
break;
}
}
};
int main(){
carfactory producecar;
car *newcar1 = producecar.createSpecificCar(benci);
car *newcar2 = producecar.createSpecificCar(baoma);
newcar1->createcar();
newcar2->createcar();
return 0;
}
2、工厂方法模式
抽象工厂类,只提供一个接口,通过子类去扩展和实现
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
//工厂方法模式
//抽象类(多态:提高基类)
class car{
public:
virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
bencicar(){
cout<<" begin create bencicar "<<endl;
}
void createcar(void){
cout<<" creating bencicar "<<endl;
}
~bencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
baomacar(){
cout<<" begin create baomacar "<<endl;
}
void createcar(void){
cout<<" creating baomacar "<<endl;
}
~baomacar(){}
};
//抽象工厂类,提供创建产品类的接口
class carfactory{
public:
virtual car* createSpecificCar()=0;
};
//工厂类子类
class bencifactory:public carfactory{
car* createSpecificCar(){
return (new bencicar());
}
};
//工厂类子类
class baomafactory:public carfactory{
car* createSpecificCar(){
return (new baomacar());
}
};
int main(){
carfactory *producecar1 = new bencifactory();
car *newcar1 = producecar1->createSpecificCar();
newcar1->createcar();
carfactory *producecar2 = new baomafactory();
car *newcar2 = producecar2->createSpecificCar();
newcar2->createcar();
return 0;
}
3、抽象工厂模式
当存在多个产品系列,而客户端只使用一个系列的产品时(选择普通产品还是高配产品),可以考虑使用抽象工厂模式。
缺点:当增加一个新系列的产品时,不仅需要现实具体的产品类,还需要增加一个新的创建接口,扩展相对困难。
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
//工厂方法模式
//抽象类(多态:提高基类)
class car{
public:
virtual void createcar(void)=0;
};
class highcar{
public:
virtual void createcar(void)=0;
};
//具体类(产品1)
class bencicar:public car{
public:
bencicar(){
cout<<" begin create bencicar "<<endl;
}
void createcar(void){
cout<<" creating bencicar "<<endl;
}
~bencicar(){}
};
//具体类(产品1,高性能)
class highbencicar:public highcar{
public:
highbencicar(){
cout<<" begin create highbencicar "<<endl;
}
void createcar(void){
cout<<" creating highbencicar "<<endl;
}
~highbencicar(){}
};
//具体类(产品2)
class baomacar:public car{
public:
baomacar(){
cout<<" begin create baomacar "<<endl;
}
void createcar(void){
cout<<" creating baomacar "<<endl;
}
~baomacar(){}
};
//具体类(产品2,高性能)
class highbaomacar:public highcar{
public:
highbaomacar(){
cout<<" begin create highbaomacar "<<endl;
}
void createcar(void){
cout<<" creating highbaomacar "<<endl;
}
~highbaomacar(){}
};
//抽象工厂类,提供创建产品类的接口
class carfactory{
public:
virtual car* createSpecificCar()=0;
virtual highcar* createSpecificHightCar()=0;
};
//工厂类子类
class bencifactory:public carfactory{
car* createSpecificCar(){
return (new bencicar());
}
highcar* createSpecificHightCar(){
return (new highbencicar());
}
};
//工厂类子类
class baomafactory:public carfactory{
car* createSpecificCar(){
return (new bencicar());
}
highcar* createSpecificHightCar(){
return (new highbaomacar());
}
};
int main(){
carfactory *producecar1 = new bencifactory();
car *newcar1 = producecar1->createSpecificCar();
newcar1->createcar();
carfactory *producecar2 = new baomafactory();
highcar *newcar2 = producecar2->createSpecificHightCar();
newcar2->createcar();
return 0;
}