工厂模式
工厂模式就是将对象实例化的过程封装起来,成批次的构造对象。
应用情景小故事:
假设有个刚起步的加工儿童男装小手工作坊,此时生产还比较单一,只能加工一款式A。大多客户都是散户,订单也很少,随来订单随做。
那此时的模式结构如下图:
#include <iostream>
using namespace std;
class ClothBoy
{
public:
virtual ~ClothBoy() = 0;
protected:
ClothBoy(){cout<<"ClothBoy..."<<endl;}
};
//A款
class ClothBoyA: public ClothBoy
{
public:
~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};
int main(){
ClothBoyA *a = new ClothBoyA();
ClothBoyA *b = new ClothBoyA();
return 0;
}
此模式的缺点就是什么事情都亲力亲为,生成过程完全暴漏在外,随着作坊的发展,订单量也越来越大,此种模式的控制变得越来越复杂。既要接订单又要手工生产,忙的不亦乐乎,几个手下也起了抱怨。老板一咬牙一跺脚“反正渠道为王,咱们现在有了订单和渠道了,以后我们光接订单,其他的生产找工厂代工就行”说干就干,没两天就有模有样的整起来了。
#include <iostream>
using namespace std;
class ClothBoy
{
public:
virtual ~ClothBoy() = 0;
protected:
ClothBoy(){cout<<"ClothBoy..."<<endl;}
};
//A款
class ClothBoyA: public ClothBoy
{
public:
~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};
///工厂类
class Factory
{
public:
~Factory(){cout<<"~Factory....."<<endl;};
Factory(){cout<<"Factory....."<<endl;};
ClothBoy* CreateClothBoyA(){return new ClothBoyA();};
private:
};
int main(){
Factory *factory = new Factory();
ClothBoy *a = factory->CreateClothBoyA();
return 0;
}
以上所做的改变只是把ClothBoy的A款的new 封装了起来。想象一下,随着市场份额的加大,消费者也不满足于单一的款式,所以公司决定开发B款,以丰富款式。
问题来了:B款的生产怎么解决
1 找另一家工厂代工?(多态,类继承层次,以新建一个类为代价)
2 还由A款工产,采用另一条生产流水线?(两条流水线相差无几啊,重复)
传递参数:
#include <iostream>
#include <string>
using namespace std;
class ClothBoy
{
public:
virtual ~ClothBoy() = 0{};
protected:
ClothBoy(){cout<<"ClothBoy..."<<endl;}
};
//A款
class ClothBoyA: public ClothBoy
{
public:
~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};
//B款
class clothBoyB: public ClothBoy
{
public:
~clothBoyB(){ cout<<"~ClothBoyB..."<<endl;};
clothBoyB(){ cout<<"ClothBoyB..."<<endl;};
protected:
private:
};
//工厂
class Factory
{
public:
~Factory(){cout<<"~Factory....."<<endl;};
Factory(){cout<<"Factory....."<<endl;};
ClothBoy* CreateClothBoy(string type)
{
if (type == "")
{
return NULL;
}else if (type == "ClothBoyA")
{
return new ClothBoyA();
}else if (type == "ClothBoyB")
{
return new clothBoyB();
}
};
private:
};
int main(){
Factory *myfactory = new Factory();
ClothBoy *a = myfactory->CreateClothBoy("ClothBoyA");
ClothBoy *b = myfactory->CreateClothBoy("ClothBoyB");
return 0;
}
至此为止,我们仅完成了factory模式的其中一个功能:封装了对象的创建
还有另外一个重要的功能,具体化类的工作延迟的子类中,因为面向对象设计原则有一条是面向抽象编程,所以:
#include <iostream>
#include <string>
using namespace std;
class ClothBoy
{
public:
virtual ~ClothBoy() = 0{};
protected:
ClothBoy(){cout<<"ClothBoy..."<<endl;}
};
//A款
class ClothBoyA: public ClothBoy
{
public:
~ClothBoyA(){ cout<<"~ClothBoyA..."<<endl;};
ClothBoyA(){ cout<<"ClothBoyA..."<<endl;}
protected:
private:
};
//B款
class clothBoyB: public ClothBoy
{
public:
~clothBoyB(){ cout<<"~ClothBoyB..."<<endl;};
clothBoyB(){ cout<<"ClothBoyB..."<<endl;};
protected:
private:
};
//工厂
class Factory
{
public:
virtual ~Factory() = 0{};
virtual ClothBoy* CreateClothBoy(string type) = 0;
protected:
Factory(){cout<<"Factory....."<<endl;};
private:
};
class ConcreteFactory:public Factory
{
public:
~ConcreteFactory(){ cout<<"~ConcreteFactory..."<<endl;};
ConcreteFactory(){cout<<"ConcreteFactory....."<<endl;};
ClothBoy* CreateClothBoy(string type)
{
if (type == "")
{
return NULL;
}else if (type == "ClothBoyA")
{
return new ClothBoyA();
}else if (type == "ClothBoyB")
{
return new clothBoyB();
}
};
protected:
private:
};
int main(){
Factory *myfactory = new ConcreteFactory();
ClothBoy *a = myfactory->CreateClothBoy("ClothBoyA");
ClothBoy *b = myfactory->CreateClothBoy("ClothBoyB");
return 0;
}
再随着公司发展,不仅仅生产男童的服装了,要增加女童服装的生产了。这时候上面的factory就不能堪当大任了,因为它只能局限一种类。此时应使用abstract factory模式:
#include <iostream>
#include <string>
using namespace std;
class ClothBoy
{
public:
virtual ~ClothBoy(){};
protected:
ClothBoy(){};
private:
};
class ClothGirl
{
public:
virtual ~ClothGirl(){};
protected:
ClothGirl(){};
private:
};
class ClothBoyA:public ClothBoy
{
public:
ClothBoyA(){cout<<"ClothBoyA..."<<endl;};
~ClothBoyA(){};
protected:
private:
};
class ClothBoyB:public ClothBoy
{
public:
ClothBoyB(){cout<<"ClothBoyB..."<<endl;};
~ClothBoyB(){};
protected:
private:
};
class ClothGirlA:public ClothGirl
{
public:
ClothGirlA(){cout<<"ClothGirlA..."<<endl;};
~ClothGirlA(){};
protected:
private:
};
class ClothGirlB:public ClothGirl
{
public:
ClothGirlB(){cout<<"ClothGirlB..."<<endl;};
~ClothGirlB(){};
protected:
private:
};
class AbstractFactory
{
public:
virtual ~AbstractFactory(){};
virtual ClothBoy* CreateClothBoy(string type) = 0;
virtual ClothGirl* CreateClothGirl(string type) = 0;
protected:
AbstractFactory(){};
private:
};
class ConcreteFactory1:public AbstractFactory
{
public:
ConcreteFactory1(){};
~ConcreteFactory1(){};
ClothBoy* CreateClothBoy(string type){
if (type == "")
{
return NULL;
}else if (type == "ClothBoyA")
{
return new ClothBoyA();
}else if (type == "ClothBoyB")
{
return new ClothBoyB();
}
};
ClothGirl* CreateClothGirl(string type){
if (type == "")
{
return NULL;
}else if (type == "ClothGirlA")
{
return new ClothGirlA();
}else if (type == "ClothGirlB")
{
return new ClothGirlB();
}
};
protected:
private:
};
class ConcreteFactory2:public AbstractFactory
{
public:
ConcreteFactory2(){};
~ConcreteFactory2(){};
ClothBoy* CreateClothBoy(string type){
if (type == "")
{
return NULL;
}else if (type == "ClothBoyA")
{
return new ClothBoyA();
}else if (type == "ClothBoyB")
{
return new ClothBoyB();
}
};
ClothGirl* CreateClothGirl(string type){
if (type == "")
{
return NULL;
}else if (type == "ClothGirlA")
{
return new ClothGirlA();
}else if (type == "ClothGirlB")
{
return new ClothGirlB();
}
};
protected:
private:
};
int main()
{
AbstractFactory* cf1 = new ConcreteFactory1();
cf1->CreateClothBoy("ClothBoyB");
cf1->CreateClothGirl("ClothGirlA");
AbstractFactory* cf2 = new ConcreteFactory2();
cf2->CreateClothBoy("ClothBoyA");
cf2->CreateClothGirl("ClothGirlB");
return 0;
}