using System;

 using System.Collections.Generic;

 using System.Linq;

 using System.Text;

 using System.Threading.Tasks;

 namespace FactoryModel

 {

     //====================使用C#，利用简单工厂模式，实现简单的计算器功能====================

     //考察时知识点：面向对象三大特性——继承、封装、多态

     /// <summary>

     /// 1.定义父类，同时也是一个封装

     /// </summary>

     class Operation

     {

         //2.因为要让子类能够对父类进行访问，故应要将参数定义为受保护的变量类型

         protected int numberA;

         protected int numberB;

         //定义属性（必写）

         public int NumberA

         {

             get { return numberA; }

             set { numberA = value; }

         }

         public int NumberB

         {

             get { return numberB; }

             set { numberB = value; }

         }

         //3.封装虚方法，以供子类进行重写

         public virtual int getResule()

         {

             int result = ;

             return result;

         }

     }

     /// <summary>

     /// 4.定义子类,继承父类，并对父类进行重写(加法)

     /// </summary>

     class OperationAdd : Operation

     {

         public override int getResule()

         {

             return numberA + numberB;

         }

     }

     /// <summary>

     /// 5.定义子类,继承父类，并对父类进行重写（减法）

     /// </summary>

     class OperationSub : Operation

     {

         public override int getResule()

         {

             return numberA - numberB;

         }

     }

     /// <summary>

     /// 6.创建工厂方法模式(抽象工厂：接口)

     /// </summary>

     interface IFactory    //父接口（父类工厂）

     {

         /// <summary>

         /// 此父接口提供一个无参的函数方法

         /// </summary>

         /// <returns></returns>

         Operation CreateOperation();

     }

     /// <summary>

     /// 定义子类工厂，并继承父类工厂（父接口）

     /// </summary>

     class FactoryAdd : IFactory

     {

         /// <summary>

         /// 封装与父类工厂同名函数（返回值类型亦相同）

         /// </summary>

         /// <returns></returns>

         public Operation CreateOperation()

         {

             //返回上面OperationAdd子类

             return new OperationAdd();

         }

     }

     /// <summary>

     /// 定义子类工厂，并继承父类工厂（父接口）

     /// </summary>

     class FactorySub : IFactory

     {

         /// <summary>

         /// 封装与父类工厂同名函数（返回值类型亦相同）

         /// </summary>

         /// <returns></returns>

         public Operation CreateOperation()

         {

             ////返回上面OperationAdd子类

             return new OperationSub();

         }

     }

     //7.主函数中进行调用

     class Program

     {

         static void Main(string[] args)

         {

             //进行加法运算,指定相应的工厂类型即可，无须再次输入运算类型

             IFactory i = new FactorySub();

             //进行减法运算

             //IFactory ii = new FactorySub();

             Operation op = i.CreateOperation();

             op.NumberA = ;

             op.NumberB = ;

             //调用子类中的方法来获取结果

             int result = op.getResule();

             Console.WriteLine(result);

             Console.ReadKey();

         }

         //如果在后续的编程中仍需要有其他的运算，则只需要在子类中加上相应的子类，

         //并在工厂方法中中加上相应的工厂类即可即可，无须需改代码，这也就是工厂方法（抽象工厂）的“利”所在

     }

 }