设计模式C++达到 3.抽象工厂

简单工厂模式和工厂模式 要求 同类型的产品子类有共同的方法。这限制了产品子类的扩展。抽象工厂能client它提供了一个接口,它是client而不必指定产品的详细信息。创建多个产品系列产品对象。在归为一类相同的子类的产品抽象工厂类。让他们继承相同的抽象子类。子类视为一组。产品族是指位于不同产品等级结构中,功能相关联的产品组成的家族。

一般位于不同等级结构的同样位置上。每个产品族中的产品数量与产品等级结构的数量同样。用户通过工厂以及族来推断

当用户使用时,必须知道哪个工厂以及哪个产品族的产品类,即通过组和族的二维坐标来确定详细的产品子类。每一个工厂子类负责一族产品。且有一个方法来生成一种类型的产品。

举个样例说明。对于抽象工厂基类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,就写了以上如此多的代码。假设产品组数变多或族数添加,都会使其难以管理。

每加入产品的第二组,工厂类和产品类接口必须改变,相反,开闭原则。

版权声明:本文博主原创文章,博客,未经同意不得转载。

上一篇:uoj#228 基础数据结构练习题


下一篇:httpclient的get带参不带参post带参不带参的简单应用