简单工厂和工厂模式都是指的是一类相同的类。
抽象工厂是针对的多个类的对象的组合。
提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。
实现:分别为火车和飞机制造发动机和轮胎,火车和飞机用不同的发动机和轮胎。
//抽象产品 发动机
class Engine
{
public:
virtual void makeEngine() = 0;
};
//具体产品 火车发动机
class TrainEngine :public Engine
{
public:
void makeEngine(){cout << "Train Engine" << endl;}
};
//具体产品 飞机发动机
class PlaneEngine :public Engine
{
public:
void makeEngine(){cout << "Plane Engine" << endl;}
};
//抽象产品 轮胎
class Tyre
{
public:
virtual void makeTyre() = 0;
};
//具体产品 火车轮胎
class TrainTyre :public Tyre
{
public:
void makeTyre(){cout << "Train Tyre" << endl;}
};
//具体产品 飞机轮胎
class PlaneTyre :public Tyre
{
public:
void makeTyre(){cout << "Plane Tyre" << endl;}
};
//抽象工厂
class Factory
{
public:
virtual Engine* cerateEngine() = 0;
virtual Tyre* createTyre() = 0;
};
//具体工厂 火车工厂
class TrainFactory :public Factory
{
Engine* cerateEngine()
{
Engine* trainEngine = new TrainEngine();
return trainEngine;
}
Tyre* createTyre()
{
Tyre* trainTyre = new TrainTyre();
return trainTyre;
}
};
//具体工厂 飞机工厂
class PlaneFactory :public Factory
{
Engine* cerateEngine()
{
Engine* planeEngine = new PlaneEngine();
return planeEngine;
}
Tyre* createTyre()
{
Tyre* planeTyre = new PlaneTyre();
return planeTyre;
}
};
int main()
{
Factory* factory = new TrainFactory();
Engine* engine = factory->cerateEngine();
Tyre* tyre = factory->createTyre();
engine->makeEngine();
tyre->makeTyre();
factory = new PlaneFactory();
engine = factory->cerateEngine();
tyre = factory->createTyre();
engine->makeEngine();
tyre->makeTyre();
delete factory;
delete engine;
delete tyre;
return 0;
}