设计模式-抽象工厂总结

*要学习某个设计模式，首先要了解该设计模式是为了解决一个什么样的问题， 
在现实中应用场景是什么，才能达到事半功倍的效果。 --Sepmay*

在添加链接描述上一篇文章中，介绍了工厂方法，对工厂方法的理念，解决的问题，以及现实中的应用都作了讲解。 之前提到的工厂方法是为了解决这样的问题，在软件系统中，经常面临着创建对象的工作，由于需求的不断变化，需要创建的对象的具体类型也会经常产生变化。
那么抽象工厂是为了解决什么问题？它与工厂方法有什么联系和区别是什么呢？

问题：在软件系统中，经常面临着需要创建“一系列相互依赖的对象”，同时，由于需求的变化，可能需要创建另一组相互依赖的对象，所以往往存在多系列对象的创建工作。

接下来进入一个案例：
假设一个工厂需要生产三种产品A，B，C，每个产品都要经过三个流程，分别为design（设计），process（加工），assemble（组装），并且每个产品的三个流程都不相同。

根据题意我们得创建三个流程对象，分别为design对象，process对象，assemble对象，每个对象中实现相应的方法，并且根据不同的产品，需要创建相应的流程对象，A得创建属于A的design，process和assemble对象，以此类推所以说三个流程之间是相互依赖的，不能A的design之后进行属于B的process流程，这样与实际情况不符合，明显是错误的。按照工厂模式的方法，大家可以尝试下，写是可以完成的，但是代码重复性也较高，较为繁琐。

抽象工厂的方法，是将有一系列依赖关系的对象抽象成一个类，通过一个类进行管理，避免了错误并且简单利落。接下来看代码：

 class Design{
public:
    virtual void Designing() = 0;
	virtual ~Design() {}
};

class Process {
public:
	virtual void Processing() = 0;
	virtual ~Process() {}
};
class Assemble {
public:
    virtual void Assembling() = 0;
	virtual ~Assemble() {}
};

class AbstractFactory{
public:
	virtual Design* Creatdesign () = 0;
	virtual Process* Creatprocess () =0;
	virtual Assemble* Creatassemble () =0;
	virtual ~AbstractFactory () {}
};

//A
class Adesign : public Design{	
	virtual void Designing() 
	{
		cout<<"Designing A..."<<endl;
	} 	
};

class Aprocess : public Process{
	virtual void Processing()
	{
		cout<<"Processing A..."<<endl;
	}
};

class Aassemble : public Assemble{
	virtual void Assembling()
	{
		cout<<"Assembling A...\n"<<endl;
	}
};

class AFactory : public AbstractFactory{
	virtual Design* Creatdesign () 
	{    return new Adesign();}
	virtual Process* Creatprocess () 
	{    return new Aprocess();}
	virtual Assemble* Creatassemble ()
	{    return new Aassemble();}
};

//B
class Bdesign : public Design{	
	virtual void Designing() 
	{
		cout<<"Designing B..."<<endl;
	} 	
};

class Bprocess : public Process{
	virtual void Processing()
	{
		cout<<"Processing B..."<<endl;
	}
};

class Bassemble : public Assemble{
	virtual void Assembling()
	{
		cout<<"Assembling B...\n"<<endl;
	}
};

class BFactory : public AbstractFactory{
	virtual Design* Creatdesign () 
	{    return new Bdesign();}
	virtual Process* Creatprocess () 
	{    return new Bprocess();}
	virtual Assemble* Creatassemble ()
	{    return new Bassemble();}
};

//C
class Cdesign : public Design{	
	virtual void Designing() 
	{
		cout<<"Designing C..."<<endl;
	} 	
};

class Cprocess : public Process{
	virtual void Processing()
	{
		cout<<"Processing C..."<<endl;
	}
};

class Cassemble : public Assemble{
	virtual void Assembling()
	{
		cout<<"Assembling C...\n"<<endl;
	}
};

class CFactory : public AbstractFactory{
	virtual Design* Creatdesign () 
	{    return new Cdesign();}
	virtual Process* Creatprocess () 
	{    return new Cprocess();}
	virtual Assemble* Creatassemble ()
	{    return new Cassemble();}
};

class Employee{
private:
	AbstractFactory* fac;
public:
	Employee(AbstractFactory* fac)
	{
		this->fac = fac;
	}

	void Result ()
	{
		Design* des = fac->Creatdesign();
		Process* pro = fac->Creatprocess();
		Assemble* ass = fac->Creatassemble();
		des->Designing();
		pro->Processing();
		ass->Assembling();
	}
};

int main()
{
	Employee worker1 = Employee(new AFactory());
	Employee worker2 = Employee(new BFactory());
	Employee worker3 = Employee(new CFactory());
	worker1.Result();
	worker2.Result();
	worker3.Result();
	return 0;
}

从上面的程序可以看出，当我们添加一个产品D的工作线非常容易，只需要根据接口再写一个符合D的操作流程即可，所以说拓展起来非常容易。但是可以发现，这种方法对产品的操作方法要求较高，需要它们的流程，操作方法一致，并且再添加更改某个对象会较复杂。
优点是确实解决了一系列依赖对象的创建问题，复用性也较高。

每个设计模式都不可避免的有它使用的场景，有它的缺点和优点，如果期望每个地方都可以更改，那每个设计模式都实现不了，如果每一点都不要求更改，那我们也就用不着设计模式。设计模式重要的是它的可变与不可变的部分，使得可变的部分实现设计的要求，尽可能让更多的部分不变，我觉得这是设计模式的闪光点。

  总结：若没有应对“多系列对象构建”的需求，那么运用简单的工厂方法就行，
   没有必要使用Abstract Method。“系列对象”指的是一系列下的对象之间
   相互依赖作用，不同系列的对象不能相互依赖。抽象工厂模式优点主要在于
   应对“新系列”的需求变动。 缺点是难以应对“新对象”的需求变动。