一、 工厂方法（Factory Method）模式
工厂方法（FactoryMethod）模式是类的创建模式，其用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。
在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不接触哪一个产品类被实例化这种细节。这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。
在Factory Method模式中，工厂类与产品类往往具有平行的等级结构，它们之间一一对应。
二、 Factory Method模式角色与结构：
抽象工厂（Creator）角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂（Concrete Creator）角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。
抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。
具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。
三、 程序举例：
using System;public abstract class Light
{
public abstract void TurnOn(); public abstract void TurnOff();
}public class BulbLight : Light{ public override void TurnOn()
{ Console.WriteLine("Bulb Light is Turned on"); } public override void TurnOff() { Console.WriteLine("Bulb Light is Turned off"); }}public class TubeLight : Light{ public override void TurnOn() { Console.WriteLine("Tube Light is Turned on"); } public override void TurnOff() { Console.WriteLine("Tube Light is Turned off"); }}public abstract class Creator{ public abstract Light factory();}public class BulbCreator : Creator{ public override Light factory() { return new BulbLight(); }}public class TubeCreator : Creator{ public override Light factory() { return new TubeLight(); }}public class Client{ public static void Main() { Creator c1 = new BulbCreator(); Creator c2 = new TubeCreator(); Light l1 = c1.factory(); Light l2 = c2.factory(); l1.TurnOn(); l1.TurnOff(); Console.WriteLine("-----------------"); l2.TurnOn(); l2.TurnOff();
}}工厂方法的活动序列图
活动过程包括：
客户端创建BulbCreator对象，客户端持有此对象的类型是Creator，而实际类型是BulbCreator。然后客户端调用BulbCreator的factory方法，之后BulbCreator调用BulbLight的构造函数创造出产品BulbLight对象。
四、 工厂方法模式与简单工厂模式
工厂方法模式与简单工厂模式再结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。
当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放－封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。
工厂方法模式退化后可以演变成简单工厂模式。
五、 Factory Method模式演化
使用接口或抽象类
抽象工厂角色和抽象场频角色都可以选择由接口或抽象类实现。
使用多个工厂方法
抽象工厂角色可以规定出多于一个的工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以提供不同的商业逻辑，以满足提供不同的产品对象的任务。
产品的循环使用
工厂方法总是调用产品类的构造函数以创建一个新的产品实例，然后将这个实例提供给客户端。而在实际情形中，工厂方法所做的事情可以相当复杂。
一个常见的复杂逻辑就是循环使用产品对象。工厂对象将已经创建过的产品登记到一个聚集中，然后根据客户所请求的产品状态，向聚集查询。如果有满足要求的产品对象，就直接将产品返回客户端；如果聚集中没有这样的产品对象，那么就创建一个新的满足要求的产品对象，然后将这个对象登记到聚集中，再返还给客户端。"享元模式（Flyweight Pattern）"就是这样一个模式。
多态性的丧失和模式的退化
一个工厂方法模式的实现依赖于工厂角色和产品角色的多态性。在有些情况下，这个模式可以出现退化。
工厂方法返回的类型应当是抽象类型，而不是具体类型。调用工厂方法的客户端应当依赖抽象产品编程，而不是具体产品。如果工厂仅仅返回一个具体产品对象，便违背了工厂方法的用意，发生退化，这时就不再是工厂模式了。
工厂的等级结构：工厂对象应当有一个抽象的超类型。如果等级结构中只有一个具体工厂类的话，抽象工厂就可以省略，发生了退化。
六、 Factory Method模式与其它模式的关系
与工厂方法模式有关的模式还包括：
模板方法模式、MVC模式、享元模式、备忘录模式
七、 另外一个例子
// Factory Method pattern -- Real World example using System;using System.Collections;// "Product"abstract class Page{}// "ConcreteProduct"class SkillsPage : Page{}// "ConcreteProduct"class EducationPage : Page{}// "ConcreteProduct"class ExperiencePage : Page{}// "ConcreteProduct"class IntroductionPage : Page{}// "ConcreteProduct"class ResultsPage : Page{}// "ConcreteProduct"class ConclusionPage : Page{}// "ConcreteProduct"class SummaryPage : Page{}// "ConcreteProduct"class BibliographyPage : Page{}// "Creator"abstract class Document{ // Fields protected ArrayList pages = new ArrayList(); // Constructor public Document() { this.CreatePages(); } // Properties public ArrayList Pages { get{ return pages; } } // Factory Method abstract public void CreatePages();}// "ConcreteCreator"class Resume : Document{ // Factory Method implementation override public void CreatePages() { pages.Add( new SkillsPage() ); pages.Add( new EducationPage() ); pages.Add( new ExperiencePage() ); }}// "ConcreteCreator"class Report : Document{ // Factory Method implementation override public void CreatePages() { pages.Add( new IntroductionPage() ); pages.Add( new ResultsPage() ); pages.Add( new ConclusionPage() ); pages.Add( new SummaryPage() ); pages.Add( new BibliographyPage() ); }}/**//// <summary>/// FactoryMethodApp test/// </summary>class FactoryMethodApp{ public static void Main( string[] args ) { Document[] docs = new Document[ 2 ]; // Note: constructors call Factory Method docs[0] = new Resume(); docs[1] = new Report(); // Display document pages foreach( Document document in docs ) { Console.WriteLine( " " + document + " ------- " ); foreach( Page page in document.Pages ) Console.WriteLine( " " + page ); } }}
参考文献：
阎宏，《Java与模式》，电子工业出版社
[美]James W. Cooper，《C#设计模式》，电子工业出版社
[美]Alan Shalloway James R. Trott，《Design Patterns Explained》，中国电力出版社
[美]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社
[美]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社
评论
最近那么有精神，是不是放假了？ 回复 更多评论
BTW：哈哈！我老婆带着我女儿去岳母家小住时，我也睡得很晚，看来大家都是这样吧。:P 回复 更多评论
builder模式下 在 director.Construct之前 product已经生成了
director.Construct只是都product进行初始化
而factory模式下 product 是由factory产生出来的 回复 更多评论
http://www.pspsoft.com/idior/archive/2005/04/14/137913.html 回复 更多评论
在您的文章中提到“使用多个工厂方法：抽象工厂角色可以规定出多于一个的工厂方法，从而使具体工厂角色实现这些不同的工厂方法，这些方法可以提供不同的商业逻辑，以满足提供不同的产品对象的任务。”我对“商业逻辑”不知道理解的对不对：抽象工厂角色中的每一个工厂方法都是返回一种产品的抽象对象，正是这种抽象对象代表了一种商业逻辑。
我对商业逻辑的概念理解模糊，觉得您的最后一个例子体现了商业逻辑：class Resume : Document
{
// Factory Method implementation
override public void CreatePages()
{
pages.Add( new SkillsPage() );
pages.Add( new EducationPage() );
pages.Add( new ExperiencePage() );
}
}
我的理解是通过多种的产品组合，体现一些特定业务，不知道这样理解对不对？
这应该是两种不同的体现业务逻辑的方式吧？
回复 更多评论
在简单工厂中，使用参数决定创建哪个具体产品类的实例，返回抽象产品类的接口；当增加一个具体产品类时，不需要更改客户代码。（因为选择语句在工厂类提供的方法中实现）
而在工厂方法中，使用具体工厂类创建具体产品类，这样一来，客户代码需要事先判断使用哪个具体工厂来创建实例，因此当增加具体产品类时，客户代码需要改变！！！（因为选择语句在客户代码中）
那么，工厂方法究竟好在何处呢？
landx_terry@hotmail.com
谢谢！
回复 更多评论
你好，你说中了问题的关键。其实上面工厂模式的代码过于简单，以至于产生上面的误解。其实“依赖注入（或控制反转）Ioc”模式以及我在《设计模式随笔－让众口不再难调 http://www.cnblogs.com/zhenyulu/articles/81761.html》中提到的“条件外置”解决的就是你说的问题。
在一个比较大的系统中，往往是多组并行开发。所以软件设计可以分步并行开发。上面代码开发过程中可以如此安排。1）由系统架构师设计好抽象产品和抽象工厂。2.1）多组并行开发具体产品和具体工厂。2.2）与此同时另外一组使用依赖注入技术开发主程序。在1的工作完成后2.1与2.2是可以并行的。按上面方案很可能产生3个Assembly。最后通过配置文件完成组装。
因此在实际应用时，主程序的那段代码是利用配置文件“注入”得到的，或者主程序是单独开发，因此可以确保不知道具体工厂是谁。Wayfarer的一篇文章曾循序渐进的讨论过系统如何演进，如何引入配置文件等，只是记不起名字了，你可以到他的Blog上看看。 回复 更多评论
谢谢老师。
继续关注
回复 更多评论
................................................................
纠正一下,并非一定要"一一对应"和"平行等级结构",例如在开始的例子中,如果TubeLight 是BulbLight 的子类,也是可以的 回复 更多评论
非常正确。 事实上，这个设计模式用在组件开发中是非常有用的，而且可以通过reflect并把具体的类名已经产生实例的参数传入工厂来产生实例。 java和csharp都是通用的，在这个点上。 回复 更多评论
看到最后的例子，我想到了盒饭。
盒饭由菜组成，某些菜构成一份
回复 更多评论
回复 更多评论
抽象类的确不能实例化。
比如：Document tempDocs= new Document ():
编译时就会出现编译错误。
但是抽象类的子类是可以实例化的。
docs[0] = new Resume();
Document[] docs = new Document[ 2 ];
并没有实例化，估计是你看错了。