设计模式之抽象工厂模式（Abstract Factory Pattern）

模式定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

类图

代码

//抽象产品类A
class AbstractProductA {
public:
    virtual void use() = 0;
    //抽象类的析构函数设置为虚函数
	virtual ~AbstractProductA() {}
};

class ProductA1 : public AbstractProductA {
public:
    void use() override
    {
    	cout << "void ProductA1::use()" << endl;
    }
};
class ProductA2 : public AbstractProductA {
public:
    void use() override
    {
    	cout << "void ProductA2::use()" << endl;
    }
};

//抽象产品类B
class AbstractProductB {
public:
    virtual void use() = 0;
    //抽象类的析构函数设置为虚函数
	virtual ~AbstractProductB() {}
};

class ProductB1 : public AbstractProductB {
public:
    void use() override
    {
    	cout << "void ProductB1::use()" << endl;
    }
};
class ProductB2 : public AbstractProductB {
public:
    void use() override
    {
    	cout << "void ProductB2::use()" << endl;
    }
};

//抽象工厂类
class AbstractFactory {
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
	virtual ~AbstractFactory() {}
};

class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
    	return new ProductA1();
	}
    AbstractProductB* createProductB() override {
    	return new ProductB1();
	}
};
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
    	return new ProductA2();
	}
    AbstractProductB* createProductB() override {
    	return new ProductB2();
	}
};


void test()
{
    //工厂1生产A1和B1
	unique_ptr<AbstractFactory> factory1(new ConcreteFactory1());
	unique_ptr<AbstractProductA> productA1(factory1->createProductA());
    unique_ptr< AbstractProductB> productB1(factory1->createProductB());
	productA1->use();
    productB1->use();
	//工厂2生产A2和B2
	cout << endl << endl;
	unique_ptr<AbstractFactory> factory2(new ConcreteFactory2());
	unique_ptr<AbstractProductA> productA2(factory2->createProductA());
    unique_ptr< AbstractProductB> productB2(factory2->createProductB());
	productA2->use();
    productB2->use();
}

抽象工厂模式的优点

1. 抽象工厂模式隔离了具体类的生成，使得客户端并不需要知道什么被创建；
2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一产品族中的对象；
3. 增加新的产品族很方便（生成新的具体工厂），无需修改已有系统代码，符合开闭原则。

抽象工厂模式的缺点

1. 增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。

使用场景

1. 用户无需关心对象的创建过程，将对象的创建和使用解耦；
2. 产品等级结构稳定，在设计完成之后不会向系统中增加新的产品等级结构或者删除已有的产品等级结构；
3. 系统中有多于一个的产品族，而每次只使用其中某一产品族。
4. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
5. 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

参考博文

1. https://design-patterns.readthedocs.io/zh-cn/latest/creational_patterns/abstract_factory.html