简单工厂模式:
把对象的创建封装在一个接口函数里,通过传入不同的标志返回不同的对象
客户不需要自己new对象,不用了解对象创建的过程,因为封装在了Factory里
缺点:
提供创建对象实例的接口函数不闭合,不能对修改关闭(开-闭原则)
工厂方法模式:
Factory父类(创建不同产品)提供了一个纯虚函数,子类(具体工厂)负责创建对应工厂的产品
做到不同产品在不同工厂里创建,还能对现有工厂和产品进行修改
缺点:
很多产品都具有关联,属于一个产品簇不能简单的拆分,不应该分放到不同的工厂中创建
比如汽车工厂,里面需要实现车灯类,轮胎类等等。
一是不符合实际产品对象的创建逻辑,二是工厂类太多了,不好维护
抽象工厂模式:
把有关联关系的属于同一个产品簇的所有产品的接口函数,放在一个抽象工厂里
其子类要去创建产品簇里面所有的产品
缺点:
AbstractFactory是抽象类,里面所有的纯虚函数都必须要重写,即使我并不需要
简单工厂模式
使用一个Factory负责指引到对应类型的方法上去,所有方法都写在了子类中
类似于Factory类保存了汽车方法的所有路线(需要手写所有车的型号)
class CAR {
protected:
string _name;
public:
CAR(string name) :_name(name) {}
virtual void show() = 0;
};
class BMW :public CAR {
public:
BMW(string name) :CAR(name) {}
void show() { cout << "宝马汽车:" << _name << endl; }
};
class AUDI :public CAR {
public:
AUDI(string name) :CAR(name) {}
void show() { cout << "奥迪汽车:" << _name << endl; }
};
class SimpleFactory { // 简单工厂类
public:
CAR* createCar(CarType name) // 传入枚举的名字
{
switch (name)
{
case baoma:
return new BMW("x1");
case aodi:
return new AUDI("a6");
default:
cerr << "传入的工厂参数不正确" << name << endl;
break;
}
return nullptr;
}
};
enum CarType // 外部枚举
{
baoma, aodi
};
int main()
{
SimpleFactory* factory = new SimpleFactory();
CAR* p1 = factory->createCar(baoma);
CAR* p2 = factory->createCar(aodi);
p1->show();
p2->show();
delete p1, p2, factory;
return 0;
}
工厂方法
主要是为了封装对象,设计了一个Factory负责把门,如果想要添加什么东西就要继承Factory并重写
类似于Factory类作为一个中转,你的所有路线都要经由它,具体什么路线自己写
class CAR {
protected:
string _name;
public:
CAR(string name) :_name(name) {}
virtual void show() = 0;
};
class BMW :public CAR {
public:
BMW(string name) :CAR(name) {}
void show() { cout << "宝马汽车:" << _name << endl; }
};
class AUDI :public CAR {
public:
AUDI(string name) :CAR(name) {}
void show() { cout << "奥迪汽车:" << _name << endl; }
};
class Factory // 工厂方法:一个总方法,如果想要添加什么方法就继承重写
{
public:
virtual CAR* createCar(string name) = 0;
};
class BMWFactory :public Factory // 宝马工厂
{
public:
CAR* createCar(string name) { return new BMW(name); }
};
class AUDIFactory :public Factory // 奥迪工厂
{
public:
CAR* createCar(string name) { return new AUDI(name); }
};
int main()
{
Factory* baoma = new BMWFactory();
Factory* aodi = new AUDIFactory(); // 两个父类指针,都利用了多态
CAR* p1 = baoma->createCar("x6"); // 现在我只需要在main中传入参数了,而不是简单方法在Factory
CAR* p2 = aodi->createCar("a8");
p1->show();
p2->show();
delete p1, p2, baoma, aodi;
return 0;
}
抽象工厂模式
在工厂方法的基础上,将关联性强的对象抽象出来作为一个类
比如Car类和Light类产品是平行的,需要通过AbstractFactory管理
缺点是AbstractFactory是抽象类,里面所有的纯虚函数都必须要重写,即使我并不需要
class Car // 一个产品,汽车类
{
protected:
string _name;
public:
Car(string name) :_name(name) {}
virtual void show() = 0;
};
class BMW :public Car {
public:
BMW(string name) :Car(name) {}
void show() { cout << "宝马汽车:" << _name << endl; }
};
class AUDI :public Car {
public:
AUDI(string name) :Car(name) {}
void show() { cout << "奥迪汽车:" << _name << endl; }
};
class Light // 另一个产品,车灯类
{
public:
virtual void show() = 0;
};
class BMWLight :public Light
{
public:
void show() { cout << "宝马的车灯" << endl; }
};
class AUDILight :public Light
{
public:
void show() { cout << "奥迪的车灯" << endl; }
};
class AbstractFactory // 抽象工厂,将目标产品的一些特征抽象出多个虚函数
{
public:
virtual Car* createCar(string name) = 0; // 工厂方法负责创建汽车
virtual Light* createCarLight() = 0; // 工厂方法负责创建车灯
};
class BMWFactory :public AbstractFactory
{
public:
Car* createCar(string name) { return new BMW(name); }
Light* createCarLight() { return new BMWLight; }
};
class AUDIFactory :public AbstractFactory
{
public:
Car* createCar(string name) { return new AUDI(name); }
Light* createCarLight() { return new AUDILight; }
};
int main()
{
AbstractFactory* baomaF = new BMWFactory();
AbstractFactory* aodiF = new AUDIFactory();
Car* c1 = baomaF->createCar("x6"); c1->show(); // 分别用产品父类指针调用对应的类型
Car* c2 = aodiF->createCar("x6"); c2->show();
Light* l1 = baomaF->createCarLight(); l1->show();
Light* l2 = aodiF->createCarLight(); l2->show();
return 0;
}