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 
#include 
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;
}

Abstract Factory Design Pattern 抽象工厂设计模式 - 总结_第1张图片


你可能感兴趣的:(Design,Pattern,设计模式)