设计模式-抽象工厂
产品族:一个品牌下面的所有产品;
产品等级:多个品牌下面的同种产品;
应用场景
抽象工厂后续的拓展是拓展产品等级,如果是拓展产品族则不建议使用抽象工厂模式
类图
代码
#include <iostream>
using namespace std;
class AbstractProductA
{
public:
virtual ~AbstractProductA(){};
protected:
AbstractProductA(){
}
};
class ProductA1:public AbstractProductA
{
public:
ProductA1(){
cout<<"ProductA1"<<endl;
}
~ProductA1(){}
};
class ProductA2:public AbstractProductA
{
public:
ProductA2(){
cout<<"ProductA2"<<endl;
}
~ProductA2(){}
};
//后续拓展ProductA3
class ProductA3:public AbstractProductA
{
public:
ProductA3(){
cout<<"ProductA3"<<endl;
}
~ProductA3(){}
};
class AbstractProductB
{
public:
virtual ~AbstractProductB(){};
protected:
AbstractProductB(){}
};
class ProductB1:public AbstractProductB
{
public:
ProductB1(){
cout<<"ProductB1"<<endl;
}
~ProductB1(){}
};
class ProductB2:public AbstractProductB
{
public:
ProductB2(){
cout<<"ProductB2"<<endl;
}
~ProductB2(){};
};
//后续拓展ProductB3
class ProductB3:public AbstractProductB
{
public:
ProductB3(){
cout<<"ProductB3"<<endl;
}
~ProductB3(){};
};
class AbstractFactory
{
public:
virtual ~AbstractFactory(){};
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
protected:
AbstractFactory(){}
private:
};
class ConcreteFactory1:public AbstractFactory
{
public:
ConcreteFactory1(){}
~ConcreteFactory1(){}
AbstractProductA* CreateProductA(){
return new ProductA1;
}
AbstractProductB* CreateProductB(){
return new ProductB1;
}
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2(){}
~ConcreteFactory2(){}
AbstractProductA* CreateProductA(){
return new ProductA2;
}
AbstractProductB* CreateProductB(){
return new ProductB2;
}
};
//后续拓展ConcreteFactory3
class ConcreteFactory3:public AbstractFactory
{
public:
ConcreteFactory3(){}
~ConcreteFactory3(){}
AbstractProductA* CreateProductA(){
return new ProductA3;
}
AbstractProductB* CreateProductB(){
return new ProductB3;
}
};
int main(int argc,char* argv[])
{
AbstractFactory* cf1 = new ConcreteFactory1();
cf1->CreateProductA();
cf1->CreateProductB();
AbstractFactory* cf2 = new ConcreteFactory2();
cf2->CreateProductA();
cf2->CreateProductB();
//后续拓展
AbstractFactory* cf3 = new ConcreteFactory3();
cf3->CreateProductA();
cf3->CreateProductB();
return 0;
}
优点
个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象(将一个系列的产品统一一起创建);
缺点
产品族扩展非常困难,要增加一个系列的某一产品,既要修改工厂抽象类里加代码,又修改具体的实现类里面加代码;
增加了系统的抽象性和理解难度;