【设计模式】创建型模式之简单工厂模式（一）

简单工厂模式

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。【来自于百度百科】

简单的理解为：创建一个工厂类，而这个工厂类会根据传入的参数，创建不同的类实例。

为何有简单工厂？

业务逻辑与界面分开，降低耦合度。

应用场景：当你的客户端不需要知道具体类的名字，具体类是如何实现，我只需要知道对外公布的一个类，并提供一个简单的调用带参数的方法，把参数传入对应的方法，可以返回一个相对应的实例，并得到对应的结果。这个时候你就可以考虑使用“简单工厂模式”。

举个例子

　　在大话设计模式中，最典型的一个例子：计算器

定义一个运算类

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

namespace _01简单工厂模式
{
    //定义一个运算类，并提供两个数字进行计算
    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 GtetResult()
        {
            double result = 0;
            return result;
        }
    }
}

加法类，并继承 Operation 类，重写父类的方法

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

namespace _01简单工厂模式
{
    class OperationAdd : Operation
    {
        //重写父类方法,实现加法运算
        public override double GtetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
}

减法类，并继承 Operation 类，重写父类的方法

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

namespace _01简单工厂模式
{
    class OperationSub:Operation
    {
        //重写父类方法,实现减法运算
        public override double GtetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
}

乘法类，并继承 Operation 类，重写父类的方法

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

namespace _01简单工厂模式
{
    class OperationMul : Operation
    {
        //重写父类方法,实现乘法运算
        public override double GtetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
}

除法类，并继承 Operation 类，重写父类的方法

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

namespace _01简单工厂模式
{
    class OperationDiv:Operation
    {
        //重写父类方法,实现除法运算
        public override double GtetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能0。");
            result = NumberA / NumberB;
            return result;
        }
    }
}

 这时候是我们最重要的一步：工厂类

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

namespace _01简单工厂模式
{
    //工厂类
    public class OperationFactory
    {
        //返回类型Operation
        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;
                default:
                    break;
            }
            return oper;
        }
    }
}

客户端实现，客户端，定义 Operation 并传递对应的参数，计算出对应的结果

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

namespace _01简单工厂模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义Operation,并传递+号
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            //获取结果
            double result = oper.GtetResult();
            //输出结果
            Console.WriteLine(result.ToString());
            Console.ReadLine();
        }
    }
}

 

模式分析

将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易

优点：客户端无需创建具体的“对象”

1. 减少与客户端依赖性
2. 代码复用
3. 可维护、可复用、可扩展

缺点：最大的问题在于工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与面向对象的开闭原则是相违背的。

1. 系统扩展难，新需求则改工厂逻辑
2. 工厂类为重要部分，一旦工厂倒闭，后续将无法继续