设计模式——简单工厂模式

面向对象——如：活字印刷术 封装、继承、多态

通过面向对象的三大特性：封装、继承、多态 降低程序耦合度。使得程序易维护、易扩展、易复用

松耦合——业务逻辑与界面逻辑分离——简单工厂模式

例如构建一个计算器功能：
1.根据计算方式，只编译该类型与方法，而不是编译所有，易于维护。例如：使用加法运算只编译加法运算而不是所有运算。
2.添加其他运算方式。例如添加次方运算，不用给工程师整个代码，发生其他计算方式代码误操作、更改、泄密等其他情况。
以下分别举例紧耦合案列、松耦合案例：

紧耦合举例

所有方法汇总在一起，导致计算时需要全部加载

       public void TryCal()
       {
            try
            {
                //输入数字A:
                string strNumberA = numberA.Text;
                //请选择运算符号(+、-、*、/)
                string strOperate = numberO.Text;
                //请输入数字B:
                string strNumberB = numberB.Text;
                numberR.Text = operation.GetResult(Convert.ToDouble(strNumberA), Convert.ToDouble(strNumberB), strOperate).ToString();
            }
            catch (Exception er)
            {
                LBError.Content = er.Message.ToString();
            }

        }
        public class operation
        {
            public static double GetResult(double A, double B, string operatesign)
            {
                double result = 0d;
                switch (operatesign)
                {
                    case "+":
                        result = A + B;
                        break;
                    case "-":
                        result = A - B;
                        break;
                    case "*":
                        result = A * B;
                        break;
                    case "/":
                        result = A / B;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }

        private void numberR_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key==Key.Enter)
            {
                TryCal();
            }
        }

松耦合举例——简单工厂模式

利用简单工厂模式，根据条件实例化对象，避免增加不必要的实例化对象。

       public void TryCall_Factory()
        {
            try
            {
               operationL opel = OperationFactory.createOperate(numberO.Text);
                opel.NumberA = Convert.ToDouble(numberA.Text);
                opel.NumberB = Convert.ToDouble(numberB.Text);
                numberR.Text = opel.Getresult().ToString();
            }
            catch (Exception er)
            {
                LBError.Content = er.Message.ToString();

            }
        }
        public class OperationFactory
        {
            public static operationL createOperate(string operatestr)
            {
                operationL operation = null;
                switch (operatestr)
                {
                    case "+":
                        operation = new OperationAdd();
                        break;
                    case "-":
                        operation = new OperationSub();
                        break;
                    case "*":
                        operation = new OperationMul();
                        break;
                    case "/":
                        operation = new OperationDiv();
                        break;
                }
                return operation;
            }
        }
        public class operationL
        {
            private Double _numberA;

            public Double NumberA
            {
                get { return _numberA; }
                set { _numberA = value; }
            }

            private Double _numberB;

            public Double NumberB
            {
                get { return _numberB; }
                set { _numberB = value; }
            }
            public virtual Double Getresult()
            {
                double result = 0d;
                return result;
            }
        }
        public class OperationAdd:operationL
        {
            public override double Getresult()
            {
                double result = 0d;
                result = NumberA + NumberB;
                return result;
            }
        }
        public class OperationSub : operationL
        {
            public override double Getresult()
            {
                double result = 0d;
                result = NumberA - NumberB;
                return result;
            }
        }
        public class OperationMul : operationL
        {
            public override double Getresult()
            {
                double result = 0d;
                result = NumberA* NumberB;
                return result;
            }
        }
        public class OperationDiv : operationL
        {
            public override double Getresult()
            {
                double result = 0d;
                if (NumberB == 0)
                    throw new Exception("除数不能为0");
                result = NumberA /NumberB;
                return result;
            }
        }