C++设计模式之1-工厂模式

（一）工厂模式描述

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

类型：创建类模式

用途：工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，降低耦合度

    达到提高灵活性的目的。

类图：

现在一般看来将工厂模式分为三类：

1）简单工厂模式（Simple Factory）

2）工厂方法模式（Factory Method）

3）抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中将工厂模式分为两类：

工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

但是两种看法本质上是一致的，而且我们没必要深究那么多，下面来看看这些工厂模式是怎么来“治病”的。

工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。

下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，

举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号A，B的处理器核。不同的客户有不同的需求，有的客户喜欢A核，有的客户偏爱B核，怎么满足这种需求呢，

简单工厂，客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

(二)简单工厂模式

简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口

先来看看它的组成

① 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。它往往由一个具体类实现。

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

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

[cpp] view plain copy print?

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

// 生成产品依据标识
typedef enum ClassType
{
	SINGCORE_A,
	SINGCORE_B,
}ClassType;

////////////////////////////////////////////////////////////////////////////////
// 基础产品类 -=> 对应于抽象产品角色
class SingCore
{
public :
	virtual ~SingCore( ){ };		// 虚析构函数 

	virtual void Show( ) = 0;		// 产品的显示函数
};

// 单核产品S -=> 对应于具体产品角色
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( ){ };				// 虚析构函数 

	SingCore* CreateSingCore(ClassType classType)
	{
		switch(classType)
		{
			case SINGCORE_A :
			{
				return new SingCoreA( );
			}

			case SINGCORE_B :
			{
				return new SingCoreB( );
			}
		}
	}
};
////////////////////////////////////////////////////////////////////////////////
//
//
//
////////////////////////////////////////////////////////////////////////////////

int main()
{

	Factory *factory = new Factory( );

	factory->CreateSingCore(SINGCORE_A)->Show( );
	factory->CreateSingCore(SINGCORE_B)->Show( );

	delete factory;
}

 首先，使用了简单工厂模式后，我们的程序更加符合现实中的情况；而且客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品，使客户端不再依赖与具体产品的创建,就像我们买产品A和产品B，我们只关心它是不是我们需要的产品，并不关心它是怎么被创建的。

但是这样设计的也有缺点，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。
       我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员
于是工厂方法模式作为救世主出现了。

三 工厂方法模式

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

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( );
}

本例采用C++设计，会造成内存泄漏，但是只是为了讲解一下工厂模式的基本思路，因此本例中不加以描述

但是在实际开发中我们可以采用在工厂类中添加生产产品链表，来避免内存泄漏。

关于简单工厂模式，工厂方法模式和抽象工厂模式的异同（2013-12-24 11:08）请参考博主转载的一篇博客

转载：http://blog.csdn.net/gatieme/article/details/17952033

时间： 2024-12-22 10:26:40

C++设计模式之1-工厂模式的相关文章

javascript设计模式中的工厂模式示例

 这篇文章主要介绍了javascript设计模式中的工厂模式示例讲解,需要的朋友可以参考下 javaScript工厂方式原始的方式   因为对象的属性可以在对象创建后动态定义,这在 JavaScript 最初引入时都会编写类似下面的代码   代码如下: var oCar = new Object; oCar.color = "blue"; oCar.doors = 4; oCar.mpg = 25; oCar.showColor = function() {   alert(this.

设计模式： 简单工厂模式

引入: 在我们的思维中,会有一种习惯,当遇到某种问题时,会直接考虑用最直接的语言去去实现它,而往往忽略了整个程序的可维护性.可扩展性. 比如,我们写一个基本的计算器功能,要求能计算四则运算,大家或许会直接写: public class ProgramDemo{ public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(

乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)

原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)[索引页][源码下载] 乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) 作者:webabcd 介绍 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 示例 有Message和MessageModel,Message有一个Insert()方法,该方法的参数是MessageModel. AbstractMessageModel usi

C#设计模式(4)——抽象工厂模式

原文:C#设计模式(4)--抽象工厂模式 一.引言 在上一专题中介绍了工厂方法模式,工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码),而工厂方法模式每个具体工厂类只完成单个实例的创建,所以它具有很好的可扩展性.但是在现实生活中,一个工厂只创建单个产品这样的例子很少,因为现在的工厂都多元化了,一个工厂创建一系列的产品,如果我们要设计这样的系统时,工厂方法模式显然在这里不适用,然后抽象工厂模式却可以很好地解决一系列产品创建的问题,这是本专

C#设计模式(2)——简单工厂模式

原文:C#设计模式(2)--简单工厂模式 一.引言 这个系列也是自己对设计模式的一些学习笔记,希望对一些初学设计模式的人有所帮助的,在上一个专题中介绍了单例模式,在这个专题中继续为大家介绍一个比较容易理解的模式--简单工厂模式. 二.简单工厂模式的介绍 说到简单工厂,自然的第一个疑问当然就是什么是简单工厂模式了? 在现实生活中工厂是负责生产产品的,同样在设计模式中,简单工厂模式我们也可以理解为负责生产对象的一个类, 我们平常编程中,当使用"new"关键字创建一个对象时,此时该类就依赖与

设计模式之四(抽象工厂模式第三回合)

原文:设计模式之四(抽象工厂模式第三回合) 前言 抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂模式最大的好处便是易于交换产品系列,由于具体工厂类,例如IFactory factory=new AccessFactory(),在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工厂即可使用不同的产品配置.我们的设计不能去防止需要的变更,那么我们的理想便是让改动变得最小,那么现在如果你要更改数据库访问,

设计模式之四(抽象工厂模式第一回合)

原文:设计模式之四(抽象工厂模式第一回合) 前言 首先关于抽象工厂模式的学习,我们需要慢慢的,由浅入深的进入.不能单刀直入,否则可能达不到预期学明白的目标. 第一回合  首先我们从最简单的数据访问程序开始吧. 下面先来看一个简单的小例子,代码很简单 public class User { public int ID{get;set;} public string Name{get;set;} } 一个简单的实体类,也相当于在SqlServer数据库中建立了相同的数据表 public class

php设计模式之简单工厂模式详解_php技巧

本文以实例形式较为详细的介绍了PHP设计模式的简单工厂模式,对于进行PHP程序设计来说有很好的借鉴作用.具体如下: 一.概念 简单工厂模式 [静态工厂方法模式](Static Factory Method) 是类的创建模式 工厂模式的几种形态: 1.简单工厂模式(Simple Factory)又叫做 静态工厂方法模式(Static Factory Method) 2.工厂方法模式(Factory Method)又叫做 多态性工厂模式(Polymorphic Factory) 3.抽象工厂模式(A

C++设计模式之抽象工厂模式_C 语言

问题描述 之前讲到了C++设计模式--工厂方法模式,我们可能会想到,后期产品会越来越多了,建立的工厂也会越来越多,工厂进行了增长,工厂变的凌乱而难于管理:由于工厂方法模式创建的对象都是继承于Product的,所以工厂方法模式中,每个工厂只能创建单一种类的产品,当需要生产一种全新的产品(不继承自Product)时,发现工厂方法是心有余而力不足. 举个例子来说:一个显示器电路板厂商,旗下的显示器电路板种类有非液晶的和液晶的:这个时候,厂商建造两个工厂,工厂A负责生产非液晶显示器电路板,工厂B负责生产

JavaScript设计模式经典之工厂模式_javascript技巧

一.工厂模式概念 工厂模式定义一个用于创建对象的接口,这个接口由子类决定实例化哪一个类.该模式使一个类的实例化延迟到了子类.而子类可以重写接口方法以便创建的时候指定自己的对象类型(抽象工厂). 这个模式十分有用,尤其是创建对象的流程赋值的时候,比如依赖于很多设置文件等.并且,你会经常在程序里看到工厂方法,用于让子类定义需要创建的对象类型. 二.工厂模式的作用和注意事项 模式作用: 1.对象构建十分复杂--我们穿鞋很简单,但是制作鞋子的过程十分复杂 2.需要依赖具体的环境创建不同的实例--工厂可以