简单工厂模式和工厂模式 要求 同一类型的产品子类拥有共同的方法,这限制了产品子类的扩展。抽象工厂可以向客户端提供一个接口,是客户端在不必指定产品的具体情况下,创建多个产品族中的产品对象。抽象工厂中将同一类的产品子类归为一类,让它们继承同一个抽象子类,将一个抽象子类的具体产品子类视为一组。产品族是指位于不同产品等级结构中,功能相关联的产品组成的家族。一般位于不同等级结构的相同位置上。每一个产品族中的产品数量与产品等级结构的数量相同。用户通过工厂以及族来判断
当用户使用时,必须知道哪个工厂以及哪个产品族的产品类,即通过组和族的二维坐标来确定具体的产品子类。每个工厂子类负责一族产品,且有一个方法来生成一种类型的产品。
举个例子说明。对于抽象工厂基类AbstractFactory派生了 3个具体的工厂类Factory1,Factory2,Factory3,则族数为3,即每个抽象产品类有3个具体子类。若有 2 个抽象产品类AbstractProductA,AbstractProductB,即2个组,则工厂类中有2个创建对象的函数createProductA,createProductB。
简单的实现:
class AbstractProductA{
public:
virtual void fun() = 0;
AbstractProductA(){}
virtual ~AbstractProductA(){}
};
class ProductA_1 : public AbstractProductA{
public:
virtual void fun(){cout<< "A_1"<<endl;}
ProductA_1(){}
virtual ~ProductA_1(){}
};
class ProductA_2 : public AbstractProductA{
public:
virtual void fun(){cout<< "A_2"<<endl;}
ProductA_2(){}
virtual ~ProductA_2(){}
};
class ProductA_3 : public AbstractProductA{
public:
virtual void fun(){cout<< "A_3"<<endl;}
ProductA_3(){}
virtual ~ProductA_3(){}
};
//B组
class AbstractProductB{
public:
virtual void fun() = 0;
AbstractProductB(){}
virtual ~AbstractProductB(){}
};
class ProductB_1 : public AbstractProductB{
public:
virtual void fun(){cout<< "B_1"<<endl;}
ProductB_1(){}
virtual ~ProductB_1(){}
};
class ProductB_2 : public AbstractProductB{
public:
virtual void fun(){cout<< "B_2"<<endl;}
ProductB_2(){}
virtual ~ProductB_2(){}
};
class ProductB_3 : public AbstractProductB{
public:
virtual void fun(){cout<< "B_3"<<endl;}
ProductB_3(){}
virtual ~ProductB_3(){}
};
class AbstractFactory{
public:
AbstractFactory(){};
virtual ~AbstractFactory();
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
class Factory1:public AbstractFactory{
public:
Factory1(){}
~Factory1(){}
AbstractProductA* createProductA(){return new ProductA_1();}
AbstractProductB* createProductB(){return new ProductB_1();}
};
class Factory2:public AbstractFactory{
public:
Factory2(){}
~Factory2(){}
AbstractProductA* createProductA(){return new ProductA_2();}
AbstractProductB* createProductB(){return new ProductB_2();}
};
class Factory3:public AbstractFactory{
public:
Factory3(){}
~Factory3(){}
AbstractProductA* createProductA(){return new ProductA_3();}
AbstractProductB* createProductB(){return new ProductB_3();}
};
抽象工厂的用处,其原始意义是为了UNIX 和Windows,两者许多操作是相同的,这些相同的对象如File,Button等,这些东西分别为Windows族和Unix族各有一份,而对File这样对象的工厂类称Unixfile和Windowsfile为一组,进行结构化的划分。
抽象工厂支持不同类型的产品,更加方便的使用同一族中间的不同类型的产品。增加一族产品时,不修改工厂类和产品类的接口,不违背开闭原则。
缺点:结构过于臃肿,即使我只是简单实现,而3x2,就写了以上如此多的代码。如果产品组数变多或族数增加,都会使其难以管理。每次增加一组产品,工厂类和产品类接口都要修改,违背开闭原则。