定义：工厂方法模式(FactoryMethod Pattern)，定义一个用于创建对象的接口，让子类决定实例化哪一个类。定义一个抽象工厂类，每一个产品，按照抽象工厂的基本要求新建一个工厂来生产新的产品。
类型：创建型模式。
类图：
参与角色：
- AbstrctProduct，提供产品生产的标准接口。
- ConcreteProductA，ConcreteProductB，按接口具体去实现生产的产品。
- AbstractFactory，提供标准工厂规模的抽象工厂。
- ConcreteFactoryA，ConcreteFactoryB，按接口标准定制的具体生产产品的在厂。
概述：
简单工厂模式，在使用时，会违背OCP原则。工厂方法模式就是为了解决这一问题而产生的。每当有一个新的产品要生产时，不用去更改原有的产品线，也不用去修改原有的工厂，一切按规定析添加。这样产品的生产流程一致，新工厂的建造也一致。工厂原有的生产管理方法便可以继续使用，而且人员也不用重新培训，就可以直接上岗。
因为当增加新的订单时，不需要去更改旧有的产品线以及工厂，这样就可以最大限度的保证原有的产品能够正常运行。这一点，就是工厂方法的核心。下面就以代码来展现这一过程。
代码：
// C++
#include <iostream>
#include <afxcom_.h>
using namespace std;
class CCellPhone
{
public:
virtual void ProducePhone()
{
cout<<"Produce Normal Phone."<<endl;
}
};
class CNokia : public CCellPhone
{
public:
virtual void ProducePhone()
{
cout<<"Produce Nokia Phone."<<endl;
}
};
class CSamsung : public CCellPhone
{
public:
virtual void ProducePhone()
{
cout<<"Produce Samsung Phone."<<endl;
}
};
class CPhoneFactory
{
public:
virtual CCellPhone* CreatePhone() = 0;
};
class CNokiaFactory : public CPhoneFactory
{
public:
virtual CCellPhone* CreatePhone()
{
CCellPhone *pPhone = new CNokia();
return pPhone;
}
};
class CSamsungFactory : public CPhoneFactory
{
public:
virtual CCellPhone* CreatePhone()
{
CCellPhone *pPhone = new CSamsung();
return pPhone;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
// Nokia cellphone production line
CPhoneFactory* pNokiaFactory = new CNokiaFactory();
CCellPhone* pNokiaPhone = pNokiaFactory->CreatePhone();
pNokiaPhone->ProducePhone();
// Samsung cellphone production line
CPhoneFactory* pSamsungFactory = new CSamsungFactory();
CCellPhone* pSamsungPhone = pSamsungFactory->CreatePhone();
pSamsungPhone->ProducePhone();
delete pNokiaPhone;
pNokiaPhone = NULL;
delete pSamsungPhone;
pSamsungPhone = NULL;
return 0;
}
// C#代码
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
namespace Phone
{
public class CellPhone
{
public virtual void ProducePhone()
{
Console.WriteLine("Produce Normal Phone.");
}
}
class Nokia : CellPhone
{
public override void ProducePhone()
{
Console.WriteLine("Produce Nokia Phone.");
}
}
class Samsung : CellPhone
{
public override void ProducePhone()
{
Console.WriteLine("Produce Samsung Phone.");
}
}
public interface IFactory
{
CellPhone CreatePhone();
}
public class NokiaFactory : IFactory
{
public CellPhone CreatePhone()
{
CellPhone phone = new Nokia();
return phone;
}
}
public class SamsungFactory : IFactory
{
public CellPhone CreatePhone()
{
CellPhone phone = new Samsung();
return phone;
}
}
class Program
{
static void Main(string[] args)
{
IFactory nokiaFactory = new NokiaFactory();
CellPhone phone = nokiaFactory.CreatePhone();
phone.ProducePhone();
IFactory samsungFactory = new SamsungFactory();
phone = samsungFactory.CreatePhone();
phone.ProducePhone();
}
}
}
package CellPhone;
public interface IFactory {
IPhone createPhone();
}
package CellPhone;
public interface IPhone {
void producePhone();
}
package CellPhone;
public class NokiaFactory implements IFactory {
public IPhone createPhone()
{
IPhone phone = new NokiaPhone();
return phone;
}
}
package CellPhone;
public class NokiaPhone implements IPhone {
public void producePhone()
{
System.out.println("Produce nokia phone.");
}
}
package CellPhone;
public class SamsungFactory implements IFactory {
public IPhone createPhone()
{
IPhone phone = new SamsungPhone();
return phone;
}
}
package CellPhone;
public class SamsungPhone implements IPhone {
public void producePhone()
{
System.out.println("Produce samsung phone.");
}
}
/**
* CellPhone.java
*/
package CellPhone;
/**
* @author feihe027@163.com
*
*/
public class CellPhone {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
IFactory factory = new NokiaFactory();
IPhone phone = factory.createPhone();
phone.producePhone();
factory = new SamsungFactory();
phone = factory.createPhone();
phone.producePhone();
}
}
优缺点：
优点，能够最大限度地保证对修改关闭，对扩展开放。新的产品，都是通过新添加代码来完成而不是去修改原有代码来完成。
缺点，每添加一个新产品，就新建一个工厂，稍显有点浪费。如果工厂过多，管理工厂也会成为一件麻烦事。抽象工厂模式正好解决这一问题。
参考资料：
《设计模式——可复用面向对象软件基础》
《Java与模式》
《大话设计模式》