**定义**：工厂方法模式(FactoryMethod Pattern)，定义一个用于创建对象的接口，让子类决定实例化哪一个类。定义一个抽象工厂类，每一个产品，按照抽象工厂的基本要求新建一个工厂来生产新的产品。
类型：创建型模式。
类图：
****
**参与角色**：
1. AbstrctProduct，提供产品生产的标准接口。
1. ConcreteProductA，ConcreteProductB，按接口具体去实现生产的产品。
1. AbstractFactory，提供标准工厂规模的抽象工厂。
1. 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();
}
}
~~~
**优缺点**：
1. 优点，能够最大限度地保证对修改关闭，对扩展开放。新的产品，都是通过新添加代码来完成而不是去修改原有代码来完成。
1. 缺点，每添加一个新产品，就新建一个工厂，稍显有点浪费。如果工厂过多，管理工厂也会成为一件麻烦事。抽象工厂模式正好解决这一问题。
**参考资料**：
1. 《设计模式——可复用面向对象软件基础》
1. 《Java与模式》
1. 《大话设计模式》
- 前言
- 设计模式六大原则
- 1——创建型模式之简单工厂模式
- 2——创建型模式之工厂方法模式
- 3——创建型模式之抽象工厂模式
- 4——创建型模式之单例模式
- 5——创建型模式之建造者模式
- 6——创建型模式之原型模式
- 7——结构型模式之适配器模式
- 8——结构型模式之桥接模式
- 9——结构型模式之组合模式
- 10——结构型模式之装饰者模式
- 11——结构型模式之外观模式
- 12——结构型模式之享元模式
- 13——结构型模式之代理模式
- 14——行为型模式之职责链模式
- 15——行为型模式之命令模式
- 16——行为型模式之解释器模式
- 17——行为型模式之迭代器模式
- 18——行为型模式之中介者模式
- 19——行为型模式之备忘录模式
- 20——行为型模式之观察者模式
- 21——行为型模式之状态模式
- 22——行为型模式之策略模式
- 23——行为型模式之模板方法模型
- 24——行为型模式之访问者模式
- 设计模式总结