概述
在大话设计模式上也看了好多遍这三个模式了，总是感觉理解上有些模式，想通过这篇博客理顺一下能够让自己加深对他们三个的理解。
通过比较三个模式，我用自己的理解介绍一下：
1. 就一块地来说，如果我在地中之中一种作物（比如：棉花）那么这用简单工厂模式比较方便。
2. 如果在这块地种不知一种作物，我要套种我要种上豆角或者更多作物，对于这种在意块儿地种多种作物的使用工厂方法比较方便。
3. 如果我要在两块或者更多块地，我要在地种种多种作物，这个时候就没有办法通过简单工厂方法来实现，而是通过抽象工厂来实现。
所以我个人认为,简单工厂是一个工厂只生产一类的产品,面对的是具体的类,工厂方法是可以生产不同的产品,把公共的方法抽象出来,然后进行创建各种各样的产品.抽象工厂把几种产品划出共同的东西,把相互依赖的对象抽象出来,只要实现这些接口就可以得到不同的产品.
以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。
（抽象工厂将在单独写在博客里）
举例：写一个简单的计算代码，要求能够计算基本的加法、减法。（下面说的举例都是指它）
简单工厂模式：
先看类图：
结合上面类图梳理一下：抽象出算法（产品基类）、加法（产品A）、减法（产品B）。
代码区段
//定义一个父类，并设置两个参数_numberA 和 _numberB
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;
}
}
//加法的操作
public class OperationAdd : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
// 减法的操作
public class OperationSub : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA - NumberB;
return result;
}
}
//如何选择加法或者减法的运算，并且实例化对象。通过简单工厂
//利用简单工厂模式能够方便的选择要求的运算。
public class OperationFactory
{
public static Operation creatoperate(string operate)
{
Operation oper=null;
switch(operate )
{
case "+":
oper=new OperationAdd ();
break;
case "-":
oper=new OperationSub ();
break;
}
return oper ;
}
//客户端代码。。。。。 通过客户端代码，达到要计算加法或者减法的目的。
static void Main(string[] args)
{
Operation oper;
oper = OperationFactory.creatoperate("+");
oper.NumberA = 4;
oper.NumberB = 3;
double result = oper.GetResult();
Console.WriteLine(result);
}
}
优缺点说明
优点：1)首先解决了代码中大量New的问题。为何要解决这个问题，好处的说明我想放到结尾总结中。
2) 用工厂方法在一个类的内部创建对象通常比直接创建对象更灵活。
缺点：对修改不封闭，新增加产品您要修改工厂。违法了鼎鼎大名的开闭法则（OCP）
工厂方法模式
先看类图
工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
代码区段
//运算 类
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;
}
}
//相对应的简单工厂类
interface IFactory
{
Operation CreateOperation();
}
//加法类的 工厂方法
class AddFactory : IFactory
{
public Operation CreateOperation()
{
return new OperationAdd();
}
}
//减法类的工厂方法
class SubFactory : IFactory
{
public Operation CreateOperation()
{
return new OperationSub();
}
}
客户端代码：
static void Main(string[] args)
{
//根据子类实例化相应的对象
IFactory operFactory = newAddFactory();
Operation oper =operFactory.CreateOperation();
oper.NumberA = 2;
oper.NumberB = 4;
Console.WriteLine(oper.GetResult());
}
结果：
优缺点说明
优点：如果要在例子中添加算法，如果使用简单工厂模式就会出现修改已有的类，这样违背了开放-封闭原则。而工厂方法就恰恰能够避免这一点。如果添加算法，只需要继续添加算法类和算法工厂就可以。
缺点：工厂方法的缺点是，需要使用客户端决定实例化哪一个工厂来实现运算类，判断选择的问题依然存在。也就是说，工厂方法把简单工厂的内部逻辑判断移到客户端代码来进行。你想要增加功能，本来是改动工厂类，而现在是要修改客户端。
这几天一直在这里徘徊犹豫，总是想着如果才能够理解的好，可是总像是有层纸戳不透，试着篇博客让自己的知识梳理一下。然后继续奋斗！抽象工厂模式见。