Abstract Factory Design Pattern 抽象工厂设计模式 - 总结

Abstract Factory Design Pattern 就是一般的Factory Design Pattern的进一步设计，增加一个抽象工厂，然后利用这个工厂可以创建不同基类的类。

当我们需要创建更多不同类的时候就可以使用这个设计模式了。

这个设计模式的代码相对会多点，但是其中的思想就是一般Factory Design Pattern，然后集合更多的基类，看起来挺大的一个设计模式，其思想是挺简单的。

其中具体的实现细节当然是可以有多种实现方法的：

1 利用Factory的基类衍生出不同的Factory，使用这些不同的Factory类创建不同基类的类对象，可以认为不同种类的对象。

2 利用一个Factory类，然后利用参数传递，根据不同的参数创建出不同的基类对象。 - 传递参数入类，或者传递参数进创建函数都是可以的。

最后，本博客已经写完了GOF的所有23中设计模式了，并给出了C++的具体可运行实现代码。

总结一下学设计模式的心得：

1 一定要自己用代码实现，可以由代码入手也是不错的选择，因为直接看GOF的书，的确是写得比较抽象的，但是有一定代码基础了，那么就可以把很多知识点连接起来了，会实现了，什么都会变得简单理解很多了。

2 不要过于拘泥于理论，记熟了也没什么用，主要还是应用为主吧，像本人的项目中，如今都已经有意识地在使用这些设计模式了，尤其是单一设计模式，builder设计模式，Factory设计模式等非常常用的设计模式，多用就有感觉了。当然也不能无视理论。

3 设计模式虽然给人感觉是高深莫测的，不过撕开了神秘面纱之后，一切都变得简单了，很多都是一些简单的算法的实现，算法其实是无处不在啊，说算法没什么用处的人，我敢说这些人99.999%的算法水平都不怎么样。

最后贴上Abstract Factory Design Pattern的代码：

#include <stdio.h>
#include <string>
using namespace std;

class Shape
{
public:
	virtual void getShape()
	{
		puts("Shape");
	}
};

class Cycle:public Shape
{
public:
	void getShape()
	{
		puts("Cycle");
	}
};

class Ellipse:public Shape
{
public:
	void getShape()
	{
		puts("Ellipse");
	}
};

class Car
{
public:
	virtual void getCar()
	{
		puts("Car");
	}
};

class Rolls_Royce:public Car
{
public:
	void getCar()
	{
		puts("Rolls-Royce");
	}
};

class Ford:public Car
{
public:
	void getCar()
	{
		puts("Ford");
	}
};

class Factory
{
public:
	Shape *createShape(string shape)
	{
		if (shape == "Cycle")
		{
			return new Cycle;
		}
		else if (shape == "Ellipse")
		{
			return new Ellipse;
		}
		return new Shape;
	}

	Car *createCar(string car)
	{
		if (car == "Rolls-Royce")
		{
			return new Rolls_Royce;
		}
		else if (car == "Ford")
		{
			return new Ford;
		}
		return new Car;
	}
};

class ShapeFactory : public Factory
{
public:
	Shape *createCycle()
	{
		return new Cycle;
	}
	Shape *createEllipse()
	{
		return new Ellipse;
	}
};

class CarFactory : public Factory
{
public:
	Car *createRolls_Royce()
	{
		return new Rolls_Royce;
	}

	Car *createFord()
	{
		return new Ford;
	}
};

int main()
{
	//使用一个工厂类对象可以创建不同的对象
	puts("Using one class to create all needed factory");
	Factory factory;
	Shape *shape = factory.createShape("Cycle");
	shape->getShape();
	delete shape;
	shape = factory.createShape("Ellipse");
	shape->getShape();
	delete shape;

	Car *car = factory.createCar("Rolls-Royce");
	car->getCar();
	delete car;
	car = factory.createCar("Ford");
	car->getCar();
	delete car;

	//使用不同的衍生类工厂创建不同的类对象测试
	puts("\nUse different factory class to create different objects");
	ShapeFactory *fac = new ShapeFactory;
	shape = fac->createCycle();
	shape->getShape();
	delete shape;
	shape = fac->createEllipse();
	shape->getShape();
	delete shape;
	delete fac;

	CarFactory *cf = new CarFactory;
	car = cf->createRolls_Royce();
	car->getCar();
	delete car;
	car = cf->createFord();
	car->getCar();
	delete car;
	delete cf;

	return 0;
}