工厂模式与抽象工厂模式解析-优快云博客

工厂模式：该模式的设计思路是简化类名和屏蔽对象的生成细节

简化一个事物有很多种方法，也就是换一个容易记住的称呼，最简单的当然就是数字作为代号，但需要使用某个具体类的功能时就指出它的代号，让它生产对象并调用它的成员方法，这样使用者就不必关心对象的生成细节。生成的对象一般以指针的形式返回（方便对对象内部成员方法的调用）。这就和工厂生产产品很像，机器都有编号，一个机器生产一种产品，使用者只用找对机器编号就可以生产对应的产品，不需要顾及编号对应的是哪台机器和产品的生成细节。一个工厂生产多种产品。

Factory 模式不单是提供了创建对象的接口，其最重要的是延迟了子类的实例化，该模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现（Factory 中只是提供了对象创建的接口，其实现将放在 Factory 的子ConcreteFactory 中进行）。

Fruit.h

#include <iostream>
using namespace std;
class Fruit//抽象类
{
public:
	Fruit(std::string name) :mname(name){}
	virtual void operation() = 0;   //水果生产函数
protected:
	std::string mname;   //只是本类和子类可见
};
class Apple :public Fruit
{
public:
	Apple(std::string name) :Fruit(name){}
	virtual void operation()
	{
		std::cout << "this is an apple!" << std::endl;
	}
};
class Banana :public Fruit
{
public:
	Banana(std::string name) :Fruit(name){}
	virtual void operation()
	{
		std::cout << "this is a banana!" << std::endl;
	}
};
class Pear :public Fruit
{
public:
	Pear(std::string name) :Fruit(name){}
	virtual void operation()
	{
		std::cout << "this is a pear!" << std::endl;
	}
};

Factory.cpp


#include <iostream>
using namespace std;
#include "Fruit.h"
class Factory
{
public:
	Fruit* createFruit(int flag)
	{
		switch (flag)
		{
		case 1:
			return new Apple("apple");
			break;
		case 2:
			return new Banana("banana");
			break;
		case 3:
			return new Pear("pear");
			break;
		default:
			std::cout << " flag is error !" << std::endl;
			break;
		}
	}
};
int main()
{
	Factory f;
	Fruit* pf = f.createFruit(1);  //Fruit类型指针指向flag=1所创建的Fruit对象
	pf->operation();     //指针调用operation函数生产水果
	return 0;
}

Factory 模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory 模式仅仅局限于一类类（就是说 Product 是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用 AbstractFactory 了。

抽象工厂模式：要解决的问题是要创建一组相关或者相互依赖的对象。

AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ ConcreteFactory）中，维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。

可以认为是工厂模式的变形，该模式显得更加的专一；该模式的设计思路是一个工厂只生产一种产品。也就是指定哪个产品在哪生产（死绑定），然后生产哪种产品就到对应的工厂生产。

工厂产品
Factory_1------->f1
Factory_2------->f2
Factory_3------->f3

Abstract_Factory.cpp

#include <iostream>
using namespace std;
#include "Fruit.h"
class Factory////抽象类
{
public:
	Factory(std::string name) :mname(name){}
	virtual Fruit* createFruit() = 0;
protected:
	std::string mname;
};
class Factory_1:public Factory
{
public:
	Factory_1(std::string name) :Factory(name){}
	virtual Fruit* createFruit()
	{
		return new Apple("apple");
	}
};
class Factory_2:public Factory
{
public:
	Factory_2(std::string name) :Factory(name){}
	virtual Fruit* createFruit()
	{
		return new Banana("banana");
	}
};
class Factory_3 :public Factory
{
public:
	Factory_3(std::string name) :Factory(name){}
	virtual Fruit* createFruit()
	{
		return new Pear("pear");
	}
};

int main()
{
	Factory* fp = new Factory_3("f3");
	Fruit* pff = fp->createFruit();
	pff->operation();
	return 0;
}

实际上， AbstractFactory 模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而 Factory 模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到， AbstractFactory 模式通常都是使用Factory模式实现（ConcreteFactory1）。

工厂模式/抽象工厂模式