设计模式（C#）——02简单工厂模式

推荐阅读：

•  我的CSDN
•  我的博客园
•  QQ群：704621321

      工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来。通俗来说，你只关心怎么用，不用关心怎么做。

工厂模式可以分为三类：

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;
    }
}