在《简单工厂模式》一节我们介绍了简单工厂模式，提到了简单工厂模式违背了开闭原则，而“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

优点：

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
• 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
• 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

应用场景：

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

模式的结构与实现

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

1. 模式的结构

工厂方法模式的主要角色如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2. 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

//抽象产品类
class AbstractProduct
{
public:
	//抽象方法：
};
 
//具体产品类
class ConcreteProduct :public AbstractProduct
{
public:
	//具体实现方法
};
 
//抽象工厂类
class AbstractFactory 
{
public:
	//抽象方法生产产品：
    virtual AbstractProduct * createProduct() = 0;
};
 
//具体工厂类
class ConcreteFactory :public AbstractFactory
{
public:
	//具体工厂生产具体产品
    
};

2. 模式实现 

2.1. 定义抽象产品和具体产品

//定义抽象产品类
class AbstractBallProduct
{
public:
	virtual ~AbstractBallProduct()/* = default;*/ //default表示默认的析构函数
	{
		std::cout << "析构 Abstractball 对象" << std::endl;
	}

	/*
	* 抽象方法
	*/
	virtual void productName() = 0;
	virtual void productIntroduction() = 0;

	virtual void productID(int id)
	{

	}

protected:
	AbstractBallProduct() = default;   //default表示默认的构造函数
};

//定义具体产品类：篮球类
class BasketballProduct :public AbstractBallProduct
{
public:
	BasketballProduct()
	{
		std::cout << "构造 Basketball 对象" << std::endl;
	}

	~BasketballProduct() /*override*/
	{
		std::cout << "析构 Basketball 对象" << std::endl;
	}

	//使用 override 有助于防止代码中出现意外的继承行为；
	void productName() override  
	{
		std::cout << "产品名称：Basketball" << std::endl;
	}

	void productIntroduction() override
	{
		std::cout << "产品介绍：Basketball" << std::endl;
	}

	//1.未使用override，表示productID是一个新的成员函数;
	//2。使用override，表示productID是重写父类同名的成员函数
	void productID(double id) /*override*/
	{
		std::cout << "产品编号：Basketball" << std::endl;
	}

public:
private:

};

//定义具体产品类：足球类
class FootballProduct :public AbstractBallProduct
{
public:
	FootballProduct()
	{
		std::cout << "构造 Football 对象" << std::endl;
	}

	~FootballProduct() /*override*/
	{
		std::cout << "析构 Football 对象" << std::endl;
	}

	void productName() override
	{
		std::cout << "产品名称：Football" << std::endl;
	}

	void productIntroduction() override
	{
		std::cout << "产品介绍：Football" << std::endl;
	}

	void productID(int id) override
	{
		std::cout << "产品编号：Football" << std::endl;
	}
public:
private:

};

//定义具体产品类：排球类
class VolleyballProduct :public AbstractBallProduct
{
public:
	VolleyballProduct()
	{
		std::cout << "构造 Volleyball 对象" << std::endl;
	}

	~VolleyballProduct() /*override*/
	{
		std::cout << "析构 Volleyball 对象" << std::endl;
	}

	void productName() override
	{
		std::cout << "产品名称：Volleyball" << std::endl;
	}

	void productIntroduction() override
	{
		std::cout << "产品介绍：Volleyball" << std::endl;
	}

	void productID(int id) override
	{
		std::cout << "产品编号：Volleyball" << std::endl;
	}
public:
private:

};

 2.2. 定义抽象工厂和具体工厂类

//定义抽象工厂类
class AbstractFactory
{
public:
	virtual ~AbstractFactory()/* = default;*/
	{
		std::cout << "析构抽象工厂对象" << std::endl;
	}
	virtual AbstractBallProduct* createProduct() = 0;
protected:
	AbstractFactory() = default;
};

//定义具体工厂类：篮球
class BasketballFactory :public AbstractFactory
{
public:
	BasketballFactory() = default;
	~BasketballFactory() override
	{
		std::cout << "析构篮球工厂对象" << std::endl;
	}
	BasketballProduct *createProduct() override {
		return  new BasketballProduct();
	}
private:

};

//定义具体工厂类：足球
class FootballFactory :public AbstractFactory
{
public:
	FootballFactory() = default;
	~FootballFactory() override
	{
		std::cout << "析构足球工厂对象" << std::endl;
	}
	FootballProduct *createProduct() override {
		return  new FootballProduct();
	}
private:

};

//定义具体工厂类：排球
class VolleyballFactory :public AbstractFactory
{
public:
	VolleyballFactory() = default;
	~VolleyballFactory() override
	{
		std::cout << "析构排球工厂对象" << std::endl;
	}
	VolleyballProduct *createProduct() override {
		return  new VolleyballProduct();
	}
private:

};

2.3. 主函数 

int main()
{
	//定义工厂类对象和产品类对象
	AbstractBallProduct* product = nullptr;
	AbstractFactory* factory = nullptr;

	factory = new BasketballFactory();
	product = factory->createProduct();
	product->productName();
	delete factory;
	delete product;
	for (size_t i = 0; i < 3; i++)
	{
		std::cout << std::endl;
	}

	factory = new FootballFactory();
	product = factory->createProduct();
	product->productName();
	delete factory;
	delete product;
	for (size_t i = 0; i < 3; i++)
	{
		std::cout << std::endl;
	}

	factory = new VolleyballFactory();
	product = factory->createProduct();
	product->productName();
	delete factory;
	delete product;

	system("pause");
	return 0;
}