Factory-Method
动机
- 在软件系统中,经常面临着创建对象的工作;由于需求的变化,需要创建的对象的具体类型经常变化。
- 如何应对这种变化?如何绕过常规的对象创建方法(new),提供一种“封装机制”来避免客户程序和这种“具体对象创建工作”的紧耦合?
模式定义
- 定义一个用于创建对象的接口(纯虚基类),让子类决定实例化哪一个类。 Factory使得一个类的实例化延迟(目的:解耦, 手段:虚函数)到子类。
- 注:自定义1个纯虚工厂基类,其中有个虚方法,它返回我们想要的具体对象,具体实现由具体的工厂子类(工厂子类继承纯虚工厂父类)实现。
#include <iostream>
#include <string>
class Product
{
public:
virtual ~Product() {}
virtual std::string getName() = 0;
// ...
};
class ConcreteProductA : public Product
{
public:
~ConcreteProductA() {}
std::string getName()
{
return "type A";
}
// ...
};
class ConcreteProductB : public Product
{
public:
~ConcreteProductB() {}
std::string getName()
{
return "type B";
}
// ...
};
class Creator
{
public:
virtual ~Creator() {}
virtual Product *createProductA() = 0;
virtual Product *createProductB() = 0;
virtual void removeProduct(Product *product) = 0;
// ...
};
class ConcreteCreator : public Creator
{
public:
~ConcreteCreator() {}
Product *createProductA()
{
return new ConcreteProductA();
}
Product *createProductB()
{
return new ConcreteProductB();
}
void removeProduct(Product *product)
{
delete product;
}
// ...
};
int main()
{
Creator *creator = new ConcreteCreator();
Product *p1 = creator->createProductA();
std::cout << "Product: " << p1->getName() << std::endl;
creator->removeProduct(p1);
Product *p2 = creator->createProductB();
std::cout << "Product: " << p2->getName() << std::endl;
creator->removeProduct(p2);
delete creator;
return 0;
}
/*
Product: type A
Product: type B
*/
何时使用
- 类无法预测它必须创建的对象的类
- 一个类希望它的子类来指定它创建的对象
总结
- Factory模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个经常变化的具体类型,紧耦合关系(new)会导致软件的脆弱。
- Factory Method模式通过面向对象的手法,将所要创建的具体对象工作延迟到子类,从而实现一种扩展(而非更改)的策略,较好地解决了这种紧耦合关系。
- Factory Method模式解决“单个对象”的需求变化。缺点在于要求创建方法/参数相同。