所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。

Factory Method工厂方法模式使一个类的实例化延迟到其子类。

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。

这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

你应该大致猜出了工厂方法模式的结构，来看下它的组成：

① 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。它由抽象类或者接口来实现。

② 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

③ 抽象产品角色：它是具体产品继承的父类或者是实现的接口。一般有抽象类或者接口来实现。

④具体产品角色：具体工厂角色所创建的对象就是此角色的实例。由具体的类来实现。

还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。

[cpp] view plain copy print ?

1. #include <iostream>  
2.   
3. ////////////////////////////////////////////////////////////////////////////////   
4. // 核心产品基类  -=> 对应于抽象产品角色  
5. class SingCore  
6. {  
7. public :  
8.     virtual ~SingCore( ){ };        // 虚析构函数  
9.        
10.     virtual void Show( ) = 0;       // 产品显示函数   
11. };   
12.   
13.   
14. // 核心产品A  -=> 对应于具体产品角色  
15. class SingCoreA : public SingCore   
16. {  
17. public :  
18.     virtual ~SingCoreA( ){ };       // 虚析构函数  
19.        
20.     void Show( )        // 产品显示函数   
21.     {  
22.         std::cout <<"SingCore A..." <<std::endl;   
23.     }  
24. };  
25.   
26. // 核心产品B  -=> 对应于具体产品角色  
27. class SingCoreB : public SingCore  
28. {  
29. public :  
30.     virtual ~SingCoreB( ){ };       // 虚析构函数   
31.       
32.     void Show( )            // 产品显示函数   
33.     {  
34.         std::cout <<"SingCore B..." <<std::endl;  
35.     }   
36. };  
37. ////////////////////////////////////////////////////////////////////////////////  
38. //   
39. //  
40. //  
41. //   
42. ////////////////////////////////////////////////////////////////////////////////  
43. // 工厂的基类 -=> 对应于抽象工厂角色  
44. class Factory  
45. {  
46. public:  
47.     virtual ~Factory( ){ };         // 虚析构函数   
48.       
49.     virtual SingCore* CreateSingCore( ) = 0;    // 生产产品的生产线  
50.        
51. };  
52.   
53. // 生产核心A的工厂 -=> 对应于具体产品角色  
54. class FactoryA : public Factory  
55. {  
56. public :  
57.     virtual ~FactoryA( ){ };            // 虚析构函数   
58.       
59.     SingCoreA* CreateSingCore( )  
60.     {  
61.         return new SingCoreA( );  
62.     }  
63. };  
64.   
65.   
66. // 生产核心B的工厂 -=> 对应于具体产品角色  
67. class FactoryB : public Factory  
68. {  
69. public :   
70.     virtual ~FactoryB( ){ };            // 虚析构函数   
71.       
72.     SingCoreB* CreateSingCore( )  
73.     {  
74.         return new SingCoreB( );  
75.     }  
76. };  
77.   
78. int main( )  
79. {  
80.     Factory *factoryA = new FactoryA( );  
81.     factoryA->CreateSingCore( )->Show( );  
82.       
83.     Factory *factoryB = new FactoryB( );  
84.     factoryB->CreateSingCore( )->Show( );  
85.   
86.     return 0;       
87. }  

#include <iostream>

//////////////////////////////////////////////////////////////////////////////// 
// 核心产品基类  -=> 对应于抽象产品角色
class SingCore
{
public :
	virtual ~SingCore( ){ };		// 虚析构函数
	 
	virtual void Show( ) = 0;		// 产品显示函数 
}; 


// 核心产品A  -=> 对应于具体产品角色
class SingCoreA : public SingCore 
{
public :
	virtual ~SingCoreA( ){ };		// 虚析构函数
	 
	void Show( )		// 产品显示函数 
	{
		std::cout <<"SingCore A..." <<std::endl; 
	}
};

// 核心产品B  -=> 对应于具体产品角色
class SingCoreB : public SingCore
{
public :
	virtual ~SingCoreB( ){ };		// 虚析构函数 
	
	void Show( )			// 产品显示函数 
	{
		std::cout <<"SingCore B..." <<std::endl;
	} 
};
////////////////////////////////////////////////////////////////////////////////
// 
//
//
// 
////////////////////////////////////////////////////////////////////////////////
// 工厂的基类 -=> 对应于抽象工厂角色
class Factory
{
public:
	virtual ~Factory( ){ };			// 虚析构函数 
	
	virtual SingCore* CreateSingCore( ) = 0;	// 生产产品的生产线
	 
};

// 生产核心A的工厂 -=> 对应于具体产品角色
class FactoryA : public Factory
{
public :
	virtual ~FactoryA( ){ };			// 虚析构函数 
	
	SingCoreA* CreateSingCore( )
	{
		return new SingCoreA( );
	}
};


// 生产核心B的工厂 -=> 对应于具体产品角色
class FactoryB : public Factory
{
public : 
	virtual ~FactoryB( ){ };			// 虚析构函数 
	
	SingCoreB* CreateSingCore( )
	{
		return new SingCoreB( );
	}
};

int main( )
{
	Factory *factoryA = new FactoryA( );
	factoryA->CreateSingCore( )->Show( );
	
	Factory *factoryB = new FactoryB( );
	factoryB->CreateSingCore( )->Show( );

	return 0;	  
}

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！就相当于市面上同样的产品有很多个牌子，有A牌子和B牌子，每家都有一个单独的工厂用来生产。这样每次增加一个新的牌子的产品上市，都会有一家新的工厂出现。

五 抽象工厂模式

       好了那到底什么是抽象工工厂呢，它到底有什么作用呢？

在将抽象工厂前我们先来认识一下产品族。

还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。每个处理器下都有A，B两种型号的。那么这里A单核和B单核就同属于一个单核产品族。A多核和B多核就同属于一个多核产品族。

对于这种情况，就需要用到抽象工厂了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，每个工厂用来生产一个产品族。

抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象

而且使用抽象工厂模式还要满足一下条件：

①系统中有多个产品族，而系统一次只可能消费其中一族产品。

②同属于同一个产品族的产品以其使用。

看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：

①抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。它由抽象类或者接口来实现。

②具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。它由具体的类来实现。

③ 抽象产品角色：它是具体产品继承的父类或者是实现的接口。一般有抽象类或者接口来实现。

④具体产品角色：具体工厂角色所创建的对象就是此角色的实例。由具体的类来实现

抽象工厂模式和工厂方法模式的区别

而且抽象工厂模式是三个里面最为抽象、最具一般性的。

你能见到的大部分抽象工厂模式都是这样的：它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。

如果说抽象工厂中的工厂是一个实际的工厂的话，那么工厂方法中的工厂更像现实中工厂的一条生产线

①比如说工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可以生产鼠标和键盘，但可能工厂A生产的是罗技的键盘和鼠标，工厂B是微软的。这样A和B就是工厂，对应于抽象工厂；每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软, 但是鼠标还是原来罗技的但是用了抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线,

抽象工厂模式适合与如下的情况

    多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。    一个抽象工厂类，可以派生出多个具体工厂类。    每个具体工厂类可以创建多个具体产品类的实例。

下面附上抽象工厂的代码

[cpp] view plain copy print ?

1. #include <iostream>  
2.   
3. ////////////////////////////////////////////////////////////////////////////////  
4. //单核产品类族  
5. ////////////////////////////////////////////////////////////////////////////////  
6. // 单核产品基类  
7. class SingleCore    
8. {    
9. public:    
10.     virtual void Show( ) const = 0;  
11. };    
12.   
13. // 单核A    
14. class SingleCoreA: public SingleCore    
15. {    
16. public:    
17.     void Show( )const   
18.     {   
19.         std::cout<<"SingleCore A"<<std::endl;   
20.     }    
21. };    
22.   
23. // 单核B    
24. class SingleCoreB: public SingleCore    
25. {    
26. public:    
27.     void Show( ) const  
28.     {   
29.         std::cout<<"SingleCore B"<<std::endl;   
30.     }    
31. };    
32.   
33.   
34.   
35. ////////////////////////////////////////////////////////////////////////////////  
36. // 多核产品类族  
37. ////////////////////////////////////////////////////////////////////////////////  
38. // 多核产品类族基类  
39. class MultiCore        
40. {      
41. public:      
42.     virtual void Show( ) const = 0;    
43. };      
44.   
45. // 多核产品A  
46. class MultiCoreA : public MultiCore        
47. {      
48. public:      
49.     void Show() const  
50.     {   
51.         std::cout<<"Multi Core A"<<std::endl;  
52.     }      
53.       
54. };      
55.   
56. // 多核产品B  
57. class MultiCoreB : public MultiCore        
58. {      
59. public:      
60.     void Show( ) const  
61.     {  
62.         std::cout<<"Multi Core B"<<std::endl;  
63.     }      
64. };      
65.   
66.   
67. // 工厂      
68. class Factory        
69. {      
70. public:      
71.     virtual SingleCore* CreateSingleCore( ) = 0;    
72.     virtual MultiCore* CreateMultiCore( ) = 0;    
73. };      
74.   
75. // 工厂A，专门用来生产A型号的处理器      
76. class FactoryA :public Factory      
77. {      
78. public:      
79.     SingleCore* CreateSingleCore( )  
80.     {   
81.         return new SingleCoreA( );   
82.     }      
83.       
84.     MultiCore* CreateMultiCore( )  
85.     {  
86.         return new MultiCoreA( );  
87.     }      
88. };      
89.   
90. // 工厂B，专门用来生产B型号的处理器      
91. class FactoryB : public Factory      
92. {      
93. public:      
94.     SingleCore* CreateSingleCore()  
95.     {  
96.         return new SingleCoreB( );  
97.     }      
98.       
99.     MultiCore* CreateMultiCore( )  
100.     {  
101.         return new MultiCoreB( );  
102.     }      
103. };     
104.   
105.   
106. int main()  
107. {  
108.     // 生产产品A系列的产品工厂   
109.     FactoryA *factoryA = new FactoryA( );  
110.     factoryA->CreateSingleCore( )->Show( );  
111.     factoryA->CreateMultiCore( )->Show( );  
112.   
113.     // 生产B系列的产品工厂   
114.     FactoryB *factoryB = new FactoryB( );  
115.     factoryB->CreateSingleCore( )->Show( );  
116.     factoryB->CreateMultiCore( )->Show( );  
117. }  

#include <iostream>

////////////////////////////////////////////////////////////////////////////////
//单核产品类族
////////////////////////////////////////////////////////////////////////////////
// 单核产品基类
class SingleCore  
{  
public:  
    virtual void Show( ) const = 0;
};  

// 单核A  
class SingleCoreA: public SingleCore  
{  
public:  
    void Show( )const 
	{ 
		std::cout<<"SingleCore A"<<std::endl; 
	}  
};  

// 单核B  
class SingleCoreB: public SingleCore  
{  
public:  
    void Show( ) const
	{ 
		std::cout<<"SingleCore B"<<std::endl; 
	}  
};  



////////////////////////////////////////////////////////////////////////////////
// 多核产品类族
////////////////////////////////////////////////////////////////////////////////
// 多核产品类族基类
class MultiCore      
{    
public:    
    virtual void Show( ) const = 0;  
};    

// 多核产品A
class MultiCoreA : public MultiCore      
{    
public:    
    void Show() const
	{ 
		std::cout<<"Multi Core A"<<std::endl;
	}    
    
};    

// 多核产品B
class MultiCoreB : public MultiCore      
{    
public:    
    void Show( ) const
	{
		std::cout<<"Multi Core B"<<std::endl;
	}    
};    


// 工厂    
class Factory      
{    
public:    
    virtual SingleCore* CreateSingleCore( ) = 0;  
    virtual MultiCore* CreateMultiCore( ) = 0;  
};    

// 工厂A，专门用来生产A型号的处理器    
class FactoryA :public Factory    
{    
public:    
    SingleCore* CreateSingleCore( )
	{ 
		return new SingleCoreA( ); 
	}    
    
	MultiCore* CreateMultiCore( )
	{
		return new MultiCoreA( );
	}    
};    

// 工厂B，专门用来生产B型号的处理器    
class FactoryB : public Factory    
{    
public:    
    SingleCore* CreateSingleCore()
	{
		return new SingleCoreB( );
	}    
    
	MultiCore* CreateMultiCore( )
	{
		return new MultiCoreB( );
	}    
};   


int main()
{
	// 生产产品A系列的产品工厂 
	FactoryA *factoryA = new FactoryA( );
	factoryA->CreateSingleCore( )->Show( );
	factoryA->CreateMultiCore( )->Show( );

	// 生产B系列的产品工厂 
	FactoryB *factoryB = new FactoryB( );
	factoryB->CreateSingleCore( )->Show( );
	factoryB->CreateMultiCore( )->Show( );
}