设计模式整理之简单工厂

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

namespace 设计模式实例
{
     class Program
     {
         /// <summary>
         /// 考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮
         /// （如圆形按钮、矩形按钮、菱形按钮等）， 这些按钮都源自同一个基类，
         /// 不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观，
         /// 如果我们希望在使用这些按钮时，不需要知道这些具体按钮类的名字，
         /// 只需要知道表示该按钮类的一个参数，并提供一个调用方便的方法，
         /// 把该参数传入方法即可返回一个相应的按钮对象，此时，就可以使用简单工厂模式。
         /// 
         /// </summary>
         /// <param name="args"></param>
         static void Main(string[] args)
         {
             Operation oper;
             Console.Write("请输入第一个数: ");
             string strNum1 = Console.ReadLine();
             Console.Write("请输入操作符(+ - * /): ");
             string strOperate = Console.ReadLine();
             oper = OperationFactory.CreateOperate(strOperate);
             Console.Write("请输入第二个数: ");
             string strNum2 = Console.ReadLine();
             oper.Num1 = Convert.ToDouble(strNum1);
             oper.Num2 = Convert.ToDouble(strNum2);
             string Result = "";
             Result = Convert.ToString(oper.GetResult());
             Console.WriteLine("结果是:" + Result);
             Console.ReadKey(true);
         }
     }
     /// <summary>
     /// 就此问题个人理解：
     /// 1、实现方法：子类继承并重写父类方法，父类只接受处理的事务，而不是自己执行，而是交给
     ///             子类对象去实现，各个对象具有父类共同属性，而执行不同操作
     /// 2、具体实现：
     /// 工厂：工厂角色负责实现创建所有实例的内部逻辑
     /// 抽象产品角色：抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
     /// 具体产品角色：具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例
     /// </summary>
     /*
      * 说通俗点有点像面向对象编程中的多态性，一个基类，有多个派生类，
      * 在另外的调用程序中，根据参数来决定返回这个基类的哪个具体的派生类，
      * 返回值为基类类型，因为基类的引用可以指向派生类对象，
      * 而且这些所有的派生类都包含有基类的函数，也就是说派生类中有相同的函数
      * 但是函数的实现可能不同。
      */

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

    public class OperationDiv : Operation
     {
         public override double GetResult()
         {
             try
             {
                 double result = 0;
                 //            if (Num2 == 0)
                 //                throw new Exception("除数不为0");
                 result = Num1 / Num2;
                 return result;
             }
             catch (Exception e)
             {
                 Console.WriteLine(e);
                 throw;
             }
         }
     }

    public class OperationMul : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = Num2 * Num1;
             return result;
         }
     }

    public class OperationSub : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = Num1 – Num2;
             return result;
         }
     }

    public class OperationAdd : Operation
     {
         public override double GetResult()
         {
             double result = 0;
             result = Num2 + Num1;
             return result;
         }
     }

    public class Operation
     {
         public double Num1 { get; set; }
         public double Num2 { get; set; }
         public virtual double GetResult()
         {
             double result = 0;
             return result;
         }
     }
 }