设计模式系列(2) 工厂模式之简单工厂模式

 

　　工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。
工厂模式有以下三种形态：

• 简单工厂（Simple Factory）模式
• 工厂方法（Factory Method）模式
• 抽象工厂（Abstract Factory）模式

　　这一篇文章要总结的是比较常用的简单工厂模式。

一，定义：

　　Simple Factory模式根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法。

二，角色介绍和结构图：

　　

　　简单工厂模式通常有三个角色。
　　1，工厂类(指的是简单工厂类)，工厂类在客户端的直接控制下创建产品(指的是具体的算法类如加法)对象。
　　2，抽象产品类(指的是运算类)，定义简单工厂创建的对象的父类或它们共同拥有的接口。可以是一个类，抽象类或接口。
　　3，具体产品类(如加法类)，定义工厂加工出的具体对象。

三，程序实现：

//抽象类
    public abstract class Operation
    {
        private double _numberA = 0d;
        private double _numberB = 0d;

        public double NumberA
        {
            set
            {
                _numberA = value;
            }
            get
            {
                return _numberA;
            }
        }
            
        public double NumberB
        {
            set
            {
                _numberB = value;
            }
            get
            {
                return _numberB;
            }
        }

        public virtual double GetResult()
        {
            double result = 0d;
            return result;
        }
    }

//具体类(由简单工厂类来实例化)
    public class OperationAdd:Operation
    {
        public override double GetResult()//override父类虚方法
        {
            double result = 0d;
            result = NumberA + NumberB;
            return result;
        }
    }

//具体类(由简单工厂类来实例化)
    public class OperationSub:Operation
    {
        public override double GetResult()
        {
            double result = 0d;
            result = NumberA - NumberB;
            return result;
        }
    }

//具体类(由简单工厂类来实例化)
    public class OperationMul:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }

//具体类(由简单工厂类来实例化)
    public 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 operation = null;
            switch (operate)
            { 
                case "+":
                    operation = new OperationAdd();//应用了里氏替换原则
                    break;
                case "-":
                    operation = new OperationSub();
                    break;
                case "*":
                    operation = new OperationMul();
                    break;
                case "/":
                    operation = new OperationDiv();
                    break;
            }
            return operation;
        }
    }

//客户端调用
    class Program
    {
        static void Main(string[] args)
        {
            Operation operation = null;
            Console.WriteLine("请输入运算符：");
            operation = OperationFactory.CreateOperate(Console.ReadLine());//根据输入的字符,工厂类来决定实例化具体的产品对象
            Console.WriteLine("请输入第一个数字：");
            operation.NumberA = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("请输入第二个数字：");
            operation.NumberB = Convert.ToDouble(Console.ReadLine());
            Console.WriteLine("结果为："+operation.GetResult());
            Console.ReadKey();
        }
    }

四，总结：

　　优点：工厂类决定了实例化哪一个具体"产品"类，客户端免去了创建产品对象的责任，而仅仅是"消费"产品，从而实现了对责任的分割，也就是程序的耦合度更低了。
　　缺点：工厂类集中了所有产品的创建逻辑，一旦工厂类不能工作，整个系统都会受到影响。任何事物都有两面性，相较于它给我们带来的好处，总体来说还是利大于弊的。