设计模式读书笔记：Abstract Factory（抽象工厂）

意图：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

结构图：来自 《23种设计模式 - 郗晓勇》

实现：https://github.com/panshiqu/patterns/tree/master/AbstractFactory

AbstractFactory

namespace NS_ABSTRACT_FACTORY {

class AbstractProductA;
class AbstractProductB;
class AbstractFactory {
public:
	AbstractFactory() {}
	virtual ~AbstractFactory() {}

	enum FACTORY_TYPE {
		FACTORY_ONE,
		FACTORY_TWO,
	};

	static AbstractFactory *getFactory(int type);

	virtual AbstractProductA *createProductA() = 0;
	virtual AbstractProductB *createProductB() = 0;
};

} /* namespace NS_ABSTRACT_FACTORY */

#include "AbstractFactory.h"
#include "ConcreteFactory1.h"
#include "ConcreteFactory2.h"

namespace NS_ABSTRACT_FACTORY {

AbstractFactory *AbstractFactory::getFactory(int type)
{
	if (FACTORY_ONE == type)
		return new ConcreteFactory1();
	else if (FACTORY_TWO == type)
		return new ConcreteFactory2();
	else return 0;
}

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteFactory1

#include "AbstractFactory.h"

namespace NS_ABSTRACT_FACTORY {

class ConcreteFactory1 : public AbstractFactory
{
public:
	ConcreteFactory1() {}
	virtual ~ConcreteFactory1() {}

	virtual AbstractProductA *createProductA();
	virtual AbstractProductB *createProductB();
};

} /* namespace NS_ABSTRACT_FACTORY */

#include "ConcreteFactory1.h"
#include "ConcreteProductA1.h"
#include "ConcreteProductB1.h"

namespace NS_ABSTRACT_FACTORY {

AbstractProductA *ConcreteFactory1::createProductA()
{
	return new ConcreteProductA1();
}

AbstractProductB *ConcreteFactory1::createProductB()
{
	return new ConcreteProductB1();
}

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteFactory2

#include "AbstractFactory.h"

namespace NS_ABSTRACT_FACTORY {

class ConcreteFactory2 : public AbstractFactory
{
public:
	ConcreteFactory2() {}
	virtual ~ConcreteFactory2() {}

	virtual AbstractProductA *createProductA();
	virtual AbstractProductB *createProductB();
};

} /* namespace NS_ABSTRACT_FACTORY */

#include "ConcreteFactory2.h"
#include "ConcreteProductA2.h"
#include "ConcreteProductB2.h"

namespace NS_ABSTRACT_FACTORY {

AbstractProductA *ConcreteFactory2::createProductA()
{
	return new ConcreteProductA2();
}

AbstractProductB *ConcreteFactory2::createProductB()
{
	return new ConcreteProductB2();
}

} /* namespace NS_ABSTRACT_FACTORY */

AbstractProductA

namespace NS_ABSTRACT_FACTORY {

class AbstractProductA {
public:
	AbstractProductA() {}
	virtual ~AbstractProductA() {}

	virtual void printSelf(void) = 0;
};

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteProductA1

#include "AbstractProductA.h"
#include <iostream>

namespace NS_ABSTRACT_FACTORY {

class ConcreteProductA1 : public AbstractProductA
{
public:
	ConcreteProductA1() {}
	virtual ~ConcreteProductA1() {}

	virtual void printSelf(void)
	{
		std::cout << "I'm ConcreteProductA1." << std::endl;
	}
};

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteProductA2

#include "AbstractProductA.h"
#include <iostream>

namespace NS_ABSTRACT_FACTORY {

class ConcreteProductA2 : public AbstractProductA
{
public:
	ConcreteProductA2() {}
	virtual ~ConcreteProductA2() {}

	virtual void printSelf(void)
	{
		std::cout << "I'm ConcreteProductA2." << std::endl;
	}
};

} /* namespace NS_ABSTRACT_FACTORY */

AbstractProductB

namespace NS_ABSTRACT_FACTORY {

class AbstractProductB {
public:
	AbstractProductB() {}
	virtual ~AbstractProductB() {}

	virtual void printSelf(void) = 0;
};

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteProductB1

#include "AbstractProductB.h"
#include <iostream>

namespace NS_ABSTRACT_FACTORY {

class ConcreteProductB1 : public AbstractProductB
{
public:
	ConcreteProductB1() {}
	virtual ~ConcreteProductB1() {}

	virtual void printSelf(void)
	{
		std::cout << "I'm ConcreteProductB1." << std::endl;
	}
};

} /* namespace NS_ABSTRACT_FACTORY */

ConcreteProductB2

#include "AbstractProductB.h"
#include <iostream>

namespace NS_ABSTRACT_FACTORY {

class ConcreteProductB2 : public AbstractProductB
{
public:
	ConcreteProductB2() {}
	virtual ~ConcreteProductB2() {}

	virtual void printSelf(void)
	{
		std::cout << "I'm ConcreteProductB2." << std::endl;
	}
};

} /* namespace NS_ABSTRACT_FACTORY */

main

#include "AbstractFactory/AbstractFactory.h"
#include "AbstractFactory/AbstractProductA.h"
#include "AbstractFactory/AbstractProductB.h"
using namespace NS_ABSTRACT_FACTORY;
int main(void)
{
	AbstractFactory *factory = AbstractFactory::getFactory(AbstractFactory::FACTORY_TWO);
	AbstractProductA *producta = factory->createProductA();
	AbstractProductB *productb = factory->createProductB();
	producta->printSelf();
	productb->printSelf();

	delete factory;
	delete producta;
	delete productb;
}

附加：

场景1：实现一个商城，售卖不同种类商品，手机，果蔬。关于一个商品它们固有商品编号，商品名称，商品介绍，关键字等等，但是手机附加的一些属性譬如手机网络，手机材质等等，相比果蔬则可能会具有保质期等属性，至少手机品类附加的那些属性果蔬基本都没有，这时我采取的做法是不同品类有共同父类：Product，数据库有type字段标识属于那个品类，我在数据库加载的时候根据type实例化不同品类商品实例，这时候应该符合简单工厂模式的场景。结构图不再提供了，仔细看一下抽象工厂的结构图，仅有一个工厂，且不再是抽象的，不再有ProductB相关系列产品，仅有一个ProductA系列产品，工厂负责实例化ProductA1和ProductA2等等，这就是简单工厂。