简单工厂模式

简单工厂模式介绍

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，说它是一种编程习惯可能更恰当些。因为它至少不是Gof23种设计模式之一。但它在实际的编程中经常被用到，而且思想也非常简单，可以说是工厂方法模式的一个引导。

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

例如某个人生病了，去医院看病医生给你开药 ，医生告诉你每天吃什么药，一次吃几片。而不需要告诉你药的制作流程和具体的成分。（医生）

病人只需要按照医生给拿的药每天按时复用即可，病人不需要了解药品的制作流程（病人）

药厂只需要保质保量的生产药品即可。药厂和病人并没有直接的关系（药厂）

举个计算器的例子

没有使用简单工厂模式

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

代码中暴露的问题很多：命名不规范、if 判断出如果这样写的话，意味着每个条件都需要判断。而且只要增加计算器的功能，那么就需要改动整体的代码。

使用简单工厂模式

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

namespace 简单工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            
           //此处为客户端出的代码
            Operation oper; 
            oper = OperationFactory.createOperate("-");  //运算符号
            oper.NumberA = 8;   //假设的NumberA为8
            oper.NumberB = 2;   //假设的NumberB为2
            double result = oper.GetResult();
            Console.WriteLine("结果是{0}",result );
            Console.ReadKey();
            

        }
        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  ;
                
            }
        }//减法类，继承运算类

        class OperationMul : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA * NumberB;
                return result;
                
            }
        }//乘法类，继承运算类

        class OperationDiv : 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 Operation createOperate(string operate)
            {
                Operation 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;
            }
        }//简单运算工厂类（核心类）

    }
}

如果需要修改界面，那么就只需要去改界面，而不需要去改动运算。如果需要添加各种复杂的运算那么只需要增加运算的子类，而不需要在去改动其他代码。

类的结构图

简单工厂的优缺点

优点：

简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对 象的尴尬局面中摆脱出来。 
外界与具体类隔离开来，偶合性低。 明确区分了各自的职责和权力，有利于整个软件体系结构的优化。 

缺点：
工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则 
虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。（这个问题在下一个工厂方法模式将得到很好的解决）