推荐阅读：
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来。通俗来说，你只关心怎么用，不用关心怎么做。
工厂模式可以分为三类：
1.简单工厂模式（Simple Factory）
2.工厂方法模式（Factory Method）
3.抽象工厂模式（Abstract Factory）
掌握简单工厂模式是我们学习工厂模式最基础的条件，只有理解了简单的，才能更深入的学习。对于刚接触设计模式的朋友来说，看前一篇单例模式的朋友觉得挺轻松，但今天要将的工厂模式可能就不是特别容易消化了。为了让大家更深刻的理解这个模式，我将给大家展现出一个有趣的学习过程。
简单工厂模式（Simple Factory Pattern）
简单工厂模式又称静态工厂方法模式（Static Factory Method）。
简单工厂模式要素：
①抽象基类：类中定义抽象一些方法，用以在子类中实现，通俗的说就是抽象产品。例：运算类my_opterator
②继承自抽象基类的子类：实现基类中的抽象方法，通俗的说就是具体的产品。例：加法类ADDopterator，乘法类MULopertator等
③工厂类：用以实例化对象。例如：factory
下面举个例子用类图来介绍一下上面几个要素之间的关系吧。
实现算术运算：
命名空间简单工厂模式中包含抽象运算基类my_opterator、四个具体运算类、工厂类factory。本案例将向大家展示如何使用简单工厂模式来进行不同的算术运算。
代码实现过程：
1.创建抽象类my_opterator
abstract class my_opterator //算法类父类
{
private double m_a, m_b;
public double A //A属性
{
get { return m_a; }
set { m_a = value; }
}
public double B //B属性
{
get { return m_b; }
set { m_b = value; }
}
abstract public double getresult(); //抽象方法，获得结果
}
2.创建继承抽象类的子类。
class ADDopterator : my_opterator //加法类
{
public override double getresult() //抽象方法的实现
{
return A + B;
}
}
class SUBoperator : my_opterator //减法类
{
public override double getresult() //抽象方法的实现
{
return A - B;
}
}
class MULopertator : my_opterator //乘法类
{
public override double getresult() //抽象方法的实现
{
return A * B;
}
}
class DIVoperator : my_opterator //除法类
{
public override double getresult() //抽象方法的实现
{
return A / B;
}
}
3.创建一个工厂，生成基于给定信息的实体类的对象
class factory //简单工厂类
{
private my_opterator m_opt;
public my_opterator createclass(string opt, double a, double b)
{
switch(opt)
{
case "+":
{
m_opt = new ADDopterator();
break;
}
case "-":
{
m_opt = new SUBoperator();
break;
}
case "*":
{
m_opt = new MULopertator();
break;
}
case "/":
{
m_opt = new DIVoperator();
break;
}
}
m_opt.A = a;
m_opt.B = b;
return m_opt;
}
}
4.使用该工厂，通过传递类型信息来获取实体类的对象。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 简单工厂模式
{
class Program
{
static void Main(string[] args)
{
string A, B;
string opt;
Console.WriteLine("请输入数字A:");
A = Console.ReadLine();
Console.WriteLine("请输入运算符:");
opt = Console.ReadLine();
Console.WriteLine("请输入数字B:");
B = Console.ReadLine();
my_opterator my_opt; //算法类父类
factory fa = new factory(); //简单工厂类
my_opt = fa.createclass(opt, Convert.ToDouble(A), Convert.ToDouble(B)); //调用生产算法方法
Console.WriteLine(my_opt.getresult());
}
}
}
从上面代码可以发现：系统难以扩展，一旦添加新产品就不得不修改简单工厂方法，这样就会造成简单工厂的实现逻辑过于复杂。
整合后的代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 简单工厂模式
{
class Program
{
static void Main(string[] args)
{
string A, B;
string opt;
Console.WriteLine("请输入数字A:");
A = Console.ReadLine();
Console.WriteLine("请输入运算符:");
opt = Console.ReadLine();
Console.WriteLine("请输入数字B:");
B = Console.ReadLine();
my_opterator my_opt; //算法类父类
factory fa = new factory(); //简单工厂类
my_opt = fa.createclass(opt, Convert.ToDouble(A), Convert.ToDouble(B)); //调用生产算法方法
Console.WriteLine(my_opt.getresult());
}
}
}
class factory //简单工厂类
{
private my_opterator m_opt;
public my_opterator createclass(string opt, double a, double b)
{
switch(opt)
{
case "+":
{
m_opt = new ADDopterator();
break;
}
case "-":
{
m_opt = new SUBoperator();
break;
}
case "*":
{
m_opt = new MULopertator();
break;
}
case "/":
{
m_opt = new DIVoperator();
break;
}
}
m_opt.A = a;
m_opt.B = b;
return m_opt;
}
}
abstract class my_opterator //算法类父类
{
private double m_a, m_b;
public double A //A属性
{
get { return m_a; }
set { m_a = value; }
}
public double B //B属性
{
get { return m_b; }
set { m_b = value; }
}
abstract public double getresult(); //抽象方法，获得结果
}
class ADDopterator : my_opterator //加法类
{
public override double getresult() //抽象方法的实现
{
return A + B;
}
}
class SUBoperator : my_opterator //减法类
{
public override double getresult() //抽象方法的实现
{
return A - B;
}
}
class MULopertator : my_opterator //乘法类
{
public override double getresult() //抽象方法的实现
{
return A * B;
}
}
class DIVoperator : my_opterator //除法类
{
public override double getresult() //抽象方法的实现
{
return A / B;
}
}