简单工厂模式与工厂方法模式

工厂模式

工厂模式是创建模式，主要是为创建对象提供过渡接口 ，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式在《深入浅出设计模式》和《大话设计模式》中分为三类：

简单工厂模式（Simple Factory）

工厂方法模式（Factory Factory）

抽象工厂模式（Abstract Factory）

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

我刚开始看着《大话设计模式》学习，抽象工厂还没看到，所以这一篇就先记一下前两种，后面看到了再更新。。。

简单工厂模式

简单工厂模式又称为静态工厂方法模式，它其实不是23种设计模式之一，只是工厂模式的简单版本（嗯，看名字就知道了）。我的理解，简单地说，它就是用一个单独的类来进行创建实例这个过程。

简单工厂模式的组成有：

工厂类角色，它是这个模式的核心，包含一定的判断逻辑。

抽象产品角色，它是具体产品所继承的父类或实现的接口。

具体产品角色，这才是使用模式要创建的具体实例的类。

类图如下：



借《大话设计模式》中的例子，展示一下模式的应用。

语言：C#

编译环境：Mac MonoDevelop

要求：实现一个计算器的功能。

计算器有不同的运算符（+、-、*、/），这些运算符都有一个共同的特点：使用两个操作数，然后得出运算结果，因此我们可以写出运算基类。

public class Operation
{
private double _numberA = 0;
private double _numberB = 0;

public double NumberA
{
get { return _numberA; }
set { _numberA = value; }
}
public double NumberB
{
get { return _numberB; }
set { _numberB = value; }
}
public virtual double GetResult()
{
double result = 0;
return result;
}
}

接下来，写出继承自运算类的加法类、减法类等。

class OperationAdd : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}

class OperationSub : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA - NumberB;
return result;
}
}

乘法类、除法类同理可以实现。

接下来是关键的工厂类，根据传入的参数的不同，动态地决定实例化哪个类。

public class OperationFactory
{
public static Operation createOperate(string operate)
{
Operation oper = null;
switch (operate) {
case "+":
oper = new OperationAdd ();
break;
case "-":
oper = new OperationSub ();
break;
}
return oper;
}
}

最后是客户端的实现。

Operation oper;
oper = OperationFactory.createOperate ("+");
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult ();
Console.WriteLine ("result = " + result.ToString());

这样就完成了简单工厂模式，如果后面要增加其他运算，比如乘方、正弦等，只需要增加相应的运算子类，然后在工厂类里增加判断即可。

写到这里，大家大概可以看出简单工厂的优缺点了。

优点：

工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅”消费”产品。简单工厂模式通过这种做法实现了对责任的分割。

缺点：

1） 当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。

2） 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂，而且违背了开闭原则。

3） 简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

工厂方法模式就可以很好地解决这种扩展的局限性。

工厂方法模式

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式的结构：

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

具体工厂角色，具体实现创建对象的过程。

抽象产品角色，具体产品继承的父类或实现的接口。

具体产品角色，具体工厂所创建的对象就是这个。

类图如下：



接下来，看看如何用工厂方法模式改造上面的例子。

// 这是一个工厂类的接口
interface IFactory
{
Operation CreateOperation();
}

// 以下是各个工厂子类，需要实现工厂接口
class AddFactory : IFactory
{
// 在不同的子类中返回不同的产品实例
public Operation CreateOperation(){
return new OperationAdd();
}
}

class SubFactory : IFactory
{
public Operation CreateOperation(){
return new OperationSub();
}
}

接下来是客户端的实现：

IFactory operFactory = new AddFactory();
Operation oper = operFactory.CreateOperation ();
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult ();
Console.WriteLine ("result = " + result.ToString());

工厂方法模式克服了简单工厂违背开闭原则的缺点，又保持了封装对象创建过程的优点。但缺点是每加一个产品，就需要增加一个产品工厂的类。简单工厂的判断是在工厂类里，工厂方法模式其实是把判断移到了客户端。不过，C#的反射机制可以解决分支判断的问题。嗯，后面再说。