【软件基础】简单计算器的实现+工厂方法模式应用+封装、继承、多态的体现

---

前言

工厂方法模式是一种常用的创建型设计模式，它提供了一种将对象的创建过程封装起来的方法。在工厂方法模式中，将对象的创建过程交给一个工厂类来完成，而不是在代码中直接调用构造函数来创建对象。这样可以使得代码更加灵活，降低耦合度，方便后期维护和扩展。

工厂方法模式的核心思想是定义一个工厂接口，该接口包含一个创建产品的方法。具体的产品创建由实现该接口的具体

---

一、运行效果

实现计算器的加减乘数计算。

二、代码

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.WriteLine("请输入运算符：\r\n");

            string operChar = Console.ReadLine();

            Operation oper = null; ;

            switch (operChar)
            {
                case "+":
                    {
                        FactoryOperationAdd facAdd = new FactoryOperationAdd();
                        oper = facAdd.creatOperation(operChar);
                        break;
                    }
                case "-":
                    {
                        FactoryOperationSub facSub = new FactoryOperationSub();
                        oper = facSub.creatOperation(operChar);
                        break;
                    }
                case "*":
                    {
                        FactoryOperationMul facMul = new FactoryOperationMul();
                        oper = facMul.creatOperation(operChar);
                        break;
                    }
                case "/":
                    {
                        FactoryOperationDiv facDiv = new FactoryOperationDiv();
                        oper = facDiv.creatOperation(operChar);
                        break;
                    }
            }

            Console.WriteLine("请输入第一个数：\r\n");
            oper.NumberA = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("请输入第二个数：\r\n");
            oper.NumberB = Convert.ToDouble(Console.ReadLine());

            double result = oper.GetResult();

            Console.WriteLine("计算结果是：" + oper.NumberA + operChar + oper.NumberB + "=" + result.ToString());
            Console.ReadKey();
        }

        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;
                result = NumberA / NumberB;
                return result;
            }
        }

        /// <summary>
        /// 工厂抽象基类
        /// </summary>
        abstract class Factory
        {
            public abstract Operation creatOperation(string oper);
        }

        class FactoryAdd : Factory
        {
            public override Operation creatOperation(string oper)
            {
                OperationAdd operAdd = new OperationAdd();
                return operAdd;
            }
        }

        class FactorySub : Factory
        {
            public override Operation creatOperation(string oper)
            {
                OperationSub operSub = new OperationSub();
                return operSub;
            }
        }

        class FactoryMul : Factory
        {
            public override Operation creatOperation(string oper)
            {
                OperationDiv operDiv = new OperationDiv();
                return operDiv;
            }
        }

        class FactoryOperationAdd:Factory
        {
            public override Operation creatOperation(string oper)
            {
                Operation operation = null;
                switch (oper)
                {
                    case "+":
                        {
                            operation = new OperationAdd();
                            break;
                        }
                }
                return operation;
            } 
        }

        class FactoryOperationSub : Factory
        {
            public override Operation creatOperation(string oper)
            {
                Operation operation = null;
                switch (oper)
                {
                    case "-":
                        {
                            operation = new OperationSub();
                            break;
                        }
                }
                return operation;
            }
        }

        class FactoryOperationMul : Factory
        {
            public override Operation creatOperation(string oper)
            {
                Operation operation = null;
                switch (oper)
                {
                    case "*":
                        {
                            operation = new OperationMul();
                            break;
                        }
                }
                return operation;
            }
        }

        class FactoryOperationDiv : Factory
        {
            public override Operation creatOperation(string oper)
            {
                Operation operation = null;
                switch (oper)
                {
                    case "/":
                        {
                            operation = new OperationDiv();
                            break;
                        }
                }
                return operation;
            }
        }
    }
}

三、简单工厂模式代码对比

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            OperationFactory operF;
            Operation oper;

            Console.WriteLine("请输入运算符：\r\n");
            string operChar=Console.ReadLine();

            operF = new OperationFactory();
            oper = operF.creatOperation(operChar);

            Console.WriteLine("请输入第一个数：\r\n");
            oper.NumberA = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("请输入第二个数：\r\n");
            oper.NumberB = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("运算结果为：\r\n");

            double result = oper.GetResult();
            Console.WriteLine(oper.NumberA.ToString() + operChar + oper.NumberB + "=" + result.ToString());

            Console.ReadKey();
        }
    }

    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;
            result = NumberA / NumberB;
            return result;
        }
    }

    /// <summary>
    /// 简单工厂创建对象，但一旦一个类的操作方式改变，整个工厂类都要改变，违反高内聚原则
    /// </summary>
    class OperationFactory      //运算对象生产工厂
    {
        public Operation creatOperation(string operation)
        {
            Operation oper = null;
            switch (operation)
            {
                case "+":
                    {
                        oper = new OperationAdd();
                        break;
                    }
                case "-":
                    {
                        oper = new OperationSub();
                        break;
                    }
                case "*":
                    {
                        oper = new OperationMul();
                        break;
                    }
                case "/":
                    {
                        oper = new OperationDiv();
                        break;
                    }   
            }
            return oper;
        }
    }
}

---

总结

工厂模式相对于简单工厂模式来说，针对每个产品类都有对应的产品工厂，这样每一类产品变动导致的工厂变动，只在对应的工厂中变动就可以。降低了耦合性，提高了内聚性。