简单工厂模式

• 对于刚学习编程的童鞋来说，能熟练的敲敲代码就已经非常棒了。举个例子，比如用C#敲一个计算器的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 计算器
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("请输入数字A：");
            string A = Console.ReadLine();
            Console.Write("请选择运算符号（+、-、*、/）：");
            string B = Console.ReadLine();
            Console.Write("请输入数字B：");
            string C = Console.ReadLine();
            string D = "";

            if (B == "+")
            {
                D = Convert.ToString(Convert.ToDouble(A) + Convert.ToDouble(C));
            }
            if (B == "-")
            {
                D = Convert.ToString(Convert.ToDouble(A) - Convert.ToDouble(C));
            }
            if (B == "*")
            {
                D = Convert.ToString(Convert.ToDouble(A) * Convert.ToDouble(C));
            }
            if (B == "/")
            {
                D = Convert.ToString(Convert.ToDouble(A) / Convert.ToDouble(C));
            }
            Console.WriteLine("结果是：" + D);
            Console.ReadKey();
        }
    }
}

• 但是对于上面的这段代码一点都不规范，比如说算除法的时候，分母是“0”怎么办？计算出来不会报错，但是会显示出结果为“⚮”，所以不够严谨，基于严谨的基础上又会从新编出另一个代码来：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 规范之后的代码
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.Write("请输入数字A：");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符号（+、-、*、/）：");
                string strOperate = Console.ReadLine();
                Console.Write("请输入数字B：");
                string strNumberB = Console.ReadLine();
                string strResult = "";
                switch (strOperate)
                {
                    case "+":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) + Convert.ToDouble(strNumberB));
                        break;
                    case "-":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) - Convert.ToDouble(strNumberB));
                        break;
                    case "*":
                        strResult = Convert.ToString(Convert.ToDouble(strNumberA) * Convert.ToDouble(strNumberB));
                        break;
                    case "/":
                        if (strNumberB != "0")
                        {
                            strResult = Convert.ToString(Convert.ToDouble(strNumberA) / Convert.ToDouble(strNumberB));
                        }
                        else
                        {
                            strResult = "除数不能为0";
                        }
                        break;
                }
                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您的输入有错误：" + ex.Message);
            }
            Console.ReadKey();
        }
    }
}

• 一个好的代码，能够随时都可以很好很方便的增删改查，如果用上面的第二套代码的话，是不是看起来就特别的复杂，甚至看都不想去看，这个时候我们就需要从面向对象出发了。

面向对象：
⑴对象。
对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。[2]
⑵对象的状态和行为。 对象具有状态，一个对象用数据值来描述它的状态。 对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。
对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中[2] ⑶类。
具有相同特性（数据元素）和行为（功能）的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象，类实际上就是一种数据类型。
类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。[2]
⑷类的结构。 在客观世界中有若干类，这些类之间有一定的结构关系。通常有两种主要的结构关系，即一般–具体结构关系，整体–部分结构关系。
①一般–具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。
②整体–部分结构称为组装结构，它们之间的关系是一种“与”关系，或者是“has a”关系。 ⑸消息和方法。
对象之间进行通信的结构叫做消息。在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。
类中操作的实现过程叫做方法，一个方法有方法名、返回值、参数、方法体。

• 使用面向对象编写程序使得程序更加的灵活，容易修改并且易于复用。所以就有了下面的这段代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 封装之后的代码
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.Write("请输入数字A：");
                string strNumberA = Console.ReadLine();
                Console.Write("请选择运算符号（+、-、*、/）:");
                string strOperate = Console.ReadLine();
                Console.Write("请输入数字B：");
                string strNumberB = Console.ReadLine();
                string strResult = "";
                strResult = Convert.ToString(Operation.GetResult(Convert.ToDouble(strNumberA), Convert.ToDouble(strNumberB), strOperate));
                Console.WriteLine("结果是：" + strResult);
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("您的输入有错误：" + ex.Message);
            }
        }
    }

    public class Operation //运算类代码
    {
        public static double GetResult(double numberA, double numberB, string operate)
        {
            double result = 0d;
            switch (operate)
            {
                case"+":
                    result = numberA + numberB;
                    break;
                case"-":
                    result = numberA - numberB;
                    break;
                case"*":
                    result = numberA * numberB;
                    break;
                case"/":
                    result = numberA / numberB;
                    break;
            }
            return result;
        }
    }

 - 这样看起来是不是更加的完美一些，然后再修改修改，改成这样：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 继承与多态
{
    class 简单工厂
    {

    static void Main(string[] args)
    {

    }
}
public class Operation //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 OperationgAdd : Operation //加法类
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}
public class OperationgSub : Operation //减法
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}
public class OperationgMul : Operation //乘法
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}
public class OperationgDiv : Operation //除法类
{ 
    public override double GetResult()
    {
        double result=0;
        if (NumberB==0)
        {
            throw new Exception("除数不能为0！");
        }
        result = NumberA / NumberB;
        return result;
    }
}

 - 其中要注意这么一个类型模式：

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

“`

• 这个类型模式就是简单工厂模式，这是最简单的一种模式，但是用上这个模式之后代码的编程会变得更加的简单和整洁，看起来更加规范，而且使得程序更加的灵活，更容易修改和多次使用。
• 以上只是基于我对简单工厂模式的了解，大神们看到了请多多指正。