C# 复习简单工厂模式,抽象类,抽象方法,简单计算器

C# 复习简单工厂模式,抽象类,简单计算器

重新复习简单工厂模式,抽象类,抽象方法,使用下拉框选择 “+”、“-”、“*”、“/”。

新建 抽象类CalFather，新建 Add(加)、新建 Sub(减)、新建 Cheng(乘)、新建 除(Chu)类。全部继承 抽象类CalFather。

通过 静态方法 GetCal 判断下拉框选择的符号，来新建 对应的类。

通过调用 GetResult 方法计算结果。

界面设计：

代码：

using System;
using System.Windows.Forms;

namespace 复习简单工厂计算器
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            cboOpear.SelectedIndex = 0;//下拉框 默认选择 第一项
        }
        private void btnResult_Click(object sender, EventArgs e)
        {
            double numberOne;//双精度浮点数 变量 用于保存 第一个数
            double numberTwo;//双精度浮点数 变量 用于保存 第二个数
            if (double.TryParse(txt1.Text, out numberOne) == false)//判断 是否 将文本框 转换为 双精度浮点数
            {
                MessageBox.Show("输入的第一个数不合法", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);//提示
                return;//中断当前
            }
            if (double.TryParse(txt2.Text, out numberTwo) == false)//判断 是否 将文本框 转换为 双精度浮点数
            {
                MessageBox.Show("输入的第二个数不合法", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);//提示
                return;//中断当前
            }
            string opera = cboOpear.SelectedItem.ToString();//将下拉框选择的值 赋值给 opera 变量
            CalFather cal = GetCal(opera, numberOne, numberTwo);//调用方法。
            double result = cal.GetResult();//调用 cal 类的方法
            txtResult.Text = numberOne + " " + opera + " " + numberTwo + " = " + result.ToString();//结果文本框 显示内容
        }
        public static CalFather GetCal(string opera, double n1, double n2)//方法
        {
            CalFather cal = null;// CalFather 变量
            switch (opera)//判断
            {
                case "+":
                    cal = new Add(n1, n2);//实例化 Add 类
                    break;
                case "-":
                    cal = new Sub(n1, n2);//实例化 Sub 类
                    break;
                case "*":
                    cal = new Cheng(n1, n2);//实例化 Cheng 类
                    break;
                case "/":
                    cal = new Chu(n1, n2);//实例化 Chu 类
                    break;
            }
            return cal;//返回
        }
    }
    public abstract class CalFather//抽象类
    {
        public double NumberOne//属性
        {
            get;
            set;
        }
        public double numberTwo//属性
        {
            get;
            set;
        }
        public CalFather(double n1, double n2)//构造函数
        {
            this.NumberOne = n1;//赋值
            this.numberTwo = n2;//赋值
        }
        public abstract double GetResult();//抽象方法
    }

    public class Add : CalFather//Add类 继承 CalFather
    {
        public Add(double n1, double n2)//构造函数
            : base(n1, n2)
        {

        }
        public override double GetResult()//重写方法
        {
            return this.NumberOne + this.numberTwo;//返回
        }
    }

    public class Sub : CalFather
    {
        public Sub(double n1, double n2)
            : base(n1, n2)
        {

        }
        public override double GetResult()
        {
            return this.NumberOne - this.numberTwo;
        }
    }

    public class Cheng : CalFather
    {
        public Cheng(double n1, double n2)
            : base(n1, n2)
        {

        }
        public override double GetResult()
        {
            return this.NumberOne * this.numberTwo;
        }
    }

    public class Chu : CalFather
    {
        public Chu(double n1, double n2)
            : base(n1, n2)
        {

        }
        public override double GetResult()
        {
            return this.NumberOne / this.numberTwo;
        }
    }
}

输出结果：