【重读设计模式】抽象工厂模式

适用场景：

1.一个对象需要依赖于其他的一组对象来创建自己（组合）。

2.这一组对象是可变的，也就是对象是抽象的。

例子：一般用户需要购买一个汽车，他只需要知道汽车的型号和颜色基本就确定了汽车的最终形态。汽车一般是由汽车装配线组装起来的，而装配的流水线其实是无需关心汽车的各个配件是什么品牌，他们只需要按部就班的将各个部件组装、调试、打磨、喷漆就完成了汽车的制造。而什么型号使用什么配件是由配件部门完成的。

设计：生产每个汽车所需要的原材料基本一致，比如有框架、座椅、轮胎、玻璃等，但是对于每个车型所使用的框架、座椅、轮胎、玻璃都不一样，对于一个厂商还有不同的车型，所使用的材料更是不一样。从这点看，每种材料都是一个抽象类，使用具体类可以表示具体的材料。我们针对每个型号组建一个配件工厂，这个工厂就负责采集和生产这个型号的车的所有原材料，由于每个车所使用的原材料种类一样，并且每个车型都需要不同的原材料，所以需要建立一个抽象的配件工厂类，并且由具体的配件工厂类去实例化相应的配件。配件工厂完成了所有的原材料，将其送到装配工厂，装配工厂按照组装、调试、打磨、喷漆等步骤后汽车出厂。

类图：

 

类实现：

//============================================================================
// Name        : abstractfactory.cpp
// Author      : tester
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================


#include <iostream>
#include <stdio.h>
using namespace std;


//汽车配件基类
class CTyre   //轮胎
{
public:
virtual void show_tyre() = 0;
};
class CTyreA : public CTyre
{
public:
void show_tyre()
{
printf("user tyre A.\n");
}
};
class CTyreB : public CTyre
{
public:
void show_tyre()
{
printf("user tyre B.\n");
}
};


class CGlass  //玻璃
{
public:
virtual void show_glass() = 0;
};
class CGlassA : public CGlass
{
public:
void show_glass()
{
printf("user glass A.\n");
}
};
class CGlassB : public CGlass
{
public:
void show_glass()
{
printf("user glass B.\n");
}
};


class CFrame  //汽车框架
{
public:
virtual void show_frame() = 0;
};
class CFrameA : public CFrame
{
public:
void show_frame()
{
printf("user frame A.\n");
}
};
class CFrameB : public CFrame
{
public:
void show_frame()
{
printf("user frame B.\n");
}
};


class CSit    //座椅
{
public:
virtual void show_sit() = 0;
};
class CSitA : public CSit
{
public:
void show_sit()
{
printf("user sit A.\n");
}
};
class CSitB : public CSit
{
public:
void show_sit()
{
printf("user sit B.\n");
}
};


//材料装配长基类
class CCarAssembFactory
{
public:
virtual CTyre* createTyre() = 0;
virtual CGlass* createGlass() = 0;
virtual CFrame* createFrame() = 0;
virtual CSit* createSit() = 0;
};


//比亚迪f1装配厂
class CCarAssembF1Factory : public CCarAssembFactory
{
public:
CTyre* createTyre()
{
return new CTyreA();
}


CGlass* createGlass()
{
return new CGlassA();
}


CFrame* createFrame()
{
return new CFrameA();
}


CSit* createSit()
{
return new CSitA();
}
};


class CCarAssembF3Factory  : public CCarAssembFactory
{
public:
CTyre* createTyre()
{
return new CTyreB();
}


CGlass* createGlass()
{
return new CGlassB();
}


CFrame* createFrame()
{
return new CFrameB();
}


CSit* createSit()
{
return new CSitB();
}
};


//比亚迪汽车基类
class CCarByd
{
public:
virtual void get_compent() = 0;


void make() //组装
{
printf("make the car\n");
}


void debug() //调试
{
printf("debug the car\n");
}


void polish()  //打磨
{
printf("polish the car\n");
}


void print()
{
printf("print the car\n");
}


protected:
CTyre* m_tyre;
CGlass* m_glass;
CFrame* m_frame;
CSit* m_sit;
CCarAssembFactory* m_assemfactory;
};


//f1生产类
class CCarBydF1 : public CCarByd
{
public:
CCarBydF1(CCarAssembFactory* factory)
{
m_assemfactory = factory;
}
void get_compent()
{
m_tyre = m_assemfactory->createTyre();
m_glass = m_assemfactory->createGlass();
m_frame = m_assemfactory->createFrame();
m_sit = m_assemfactory->createSit();
}
};


//f1生产类
class CCarBydF3 : public CCarByd
{
public:
CCarBydF3(CCarAssembFactory* factory)
{
m_assemfactory = factory;
}
void get_compent()
{
m_tyre = m_assemfactory->createTyre();
m_glass = m_assemfactory->createGlass();
m_frame = m_assemfactory->createFrame();
m_sit = m_assemfactory->createSit();
}
};




int main(int argc, char* argv[]) {
cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!


CCarByd* bydcar = NULL;
if(argv[1] == "F1")
{
CCarAssembFactory* carassemb = new CCarAssembF1Factory;
bydcar = new CCarBydF1(carassemb);
}
else// if(argv[2] == "F3")
{
CCarAssembFactory* carassemb = new CCarAssembF3Factory;
bydcar = new CCarBydF3(carassemb);
}


bydcar->make();
bydcar->debug();
bydcar->polish();
bydcar->print();
return 0;
}

总结，回过头来看抽象工厂模式，其实还是挺复杂的，但是其设计思路是简单的，将一组对象放在工厂里一起实例化，如果将这一组看成是一个，那么这个就是工厂方法模式。如果掌握的工厂方法模式，则抽象工厂模式也是很容易理解的。