工厂模式分三类：
- 简单工厂
- 工厂方法
- 抽象工厂
简单工厂不属于设计模式，因为其违背了设计模式的开闭原则，后面会有介绍。
工厂方法
factory_function.png
相关元素：
- 抽象工厂
- 具体工厂
- 抽象产品
- 具体产品
示例
抽象产品
class Car {
public:
virtual void printInfo()=0;
};
具体产品
class BenChi :public Car {
public:
void printInfo() {
cout << "BenChi" << endl;
}
};
class Aodi :public Car {
public:
void printInfo() {
cout << "Aodi" << endl;
}
};
抽象工厂
class AbstractFactory {
public:
virtual Car * createCar() = 0;
};
具体工厂：
class FactoryBenchi :public AbstractFactory {
public:
Car * createCar() {
return new BenChi();
};
};
class FactoryAodi :public AbstractFactory {
public:
Car * createCar() {
return new Aodi();
};
};
这是一个比较标准的工厂方法设计模式。车可以生产车，那具体的奥迪车工厂可以生产奥迪车，奔驰车工厂可以生产奔驰的车。当需要生产法拉利的车时，我们只需要实现一个法拉利的产品，然后实现一个法拉利的工厂即可，而不需要修改之前的代码。这符合开闭原则。
简单工厂
factory_simple.png
这是工厂模式的简单实现方式，包含元素
- 工厂类
- 抽象产品
- 抽象方法
示例
这里抽象产品和抽象方法和前面一样。
工厂类
class SimpleFactory{
public:
static Car * createCar(const string type) {
if (type == string("benchi")) {
return new BenChi();
}
else if (type == string("aodi")) {
return new Aodi();
}
else {
return NULL;
}
}
};
我们看到工厂类就是一个单独的类，通过传入的参数来区分返回什么样的产品。比如：当需要生产法拉利时，我们需要修改工厂类的方法。这不符合开闭原则，所以它不属于设计模式。只是工厂模式的一个变相简单的实现。
抽象工厂
前面说到工厂方法只能生产一个类型的产品。当我们需要生产一系列的产品，比如：我们需要奥迪的发动机，那么肯定也是在奥迪的工厂生产，那么这里就可以使用抽象工厂设计模式
元素
- 抽象工厂
- 具体工厂
- 抽象产品（多个）
- 具体产品
示例
这里我们再Car的基础上在增加一个产品Engine
class Engine {
public:
virtual void printName() = 0;
};
实现类：
class EngineBenchi :public Engine {
public:
void printName() {
cout << "benchi engine" << endl;
}
};
class EngineAodi :public Engine {
public:
void printName() {
cout << "aodi engine" << endl;
}
};
抽象类也需要进行修改：
class AbstractFactory {
public:
virtual Car * createCar() = 0;
virtual Engine * createEngine() = 0;
};
实现类：
class FactoryBenchi :public AbstractFactory {
public:
Car * createCar() {
return new BenChi();
};
Engine * createEngine() {
return new EngineBenchi();
}
};
class FactoryAodi :public AbstractFactory {
public:
Car * createCar() {
return new Aodi();
};
Engine * createEngine() {
return new EngineAodi();
}
};
测试代码：
int main()
{
AbstractFactory *factory = NULL;
Car* car = NULL;
Engine* engine = NULL;
factory=new FactoryBenchi();
car = factory->createCar();
car->printInfo();
engine = factory->createEngine();
engine->printName();
delete factory;
delete car;
delete engine;
factory = new FactoryAodi();
car = factory->createCar();
car->printInfo();
engine = factory->createEngine();
engine->printName();
delete factory;
delete car;
delete engine;
return 0;
}
这样我们就完成的奥迪工厂既可以生产车，也可以生产发动机。同样我们也发现了他的缺点。当需要再添加一种商品时，发现需要修改很多地方。抽象工厂需要修改，同时所有的实现类都需要发生修改。产品的扩展很复杂。优点当然也明显，它是的产品族的多个产品设计在一起工作时，它能保证使用的是同一个产品族的产品。
