面向对象编程中，大多数都是以类作为数据封装的基本单位，它将数据和操作数据的方法结合成一个类。设计类时不希望直接存取类中的数据，而是希望通过方法来存取数据，这样就可以达到封装数据的目的，方便以后的维护升级，也可以在操作数据时多一层判断。此外，封装还可以解决数据存取的权限问题，可以使用封装将数据形成一个封闭的空间，然后设置数据在空间内部和外部的使用权限。

程序界面：

程序代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Calculator : Form
    {
        public Calculator()
        {
            InitializeComponent();
        }
        public class SZ
        {
            private double sz1 = 0;
            private double sz2= 0;
            public double SZ1
            {
                get { return sz1; }
                set { sz1 = value; }
            }
            public double SZ2
            {
                get { return sz2; }
                set { sz2 = value; }
            }
            //将类中的成员定义成虚拟的，表示这些成员将会在继承后重写其中的内容。
            public virtual double GetResult()
            {
                double result = 0;
                return result;
            }
        }
        //添加四个加减乘除类继承SZ类，重写父类中的GetResult方法。
        //加法类
        public class OperationAdd : SZ
        {
            public override double GetResult()
            {
                double result = 0;
                result = SZ1 + SZ2;
                return result;
            }
        }
        //减法类 
        public class OperationSub : SZ
        {
            public override double GetResult()
            {
                double result = 0;
                result = SZ1 - SZ2;
                return result;
            }
        }
        //乘法类
        public class OperationMul : SZ
        {
            public override double GetResult()
            {
                double result = 0;
                result = SZ1 * SZ2;
                return result;
            }
        }
        //除法类
        public class OperationDiv : SZ
        {
            public override double GetResult()
            {
                double result = 0;
                if (SZ2 == 0)
                {
                    throw new Exception("除数不能为0");
                }
                result = SZ1 * 1.0 / SZ2;
                return result;
            }
        }
        // 添加一个运算符枚举类，代表四则运算符号     
        public enum EnumOperator
        {
            None = 0,Add = 1,Subtraction = 2,Multiply = 3,Divide = 4
        }
        public class OperatorInput
        {
            //只需输入运算符就能实例化出合适的对象
            public static SZ createOperate(EnumOperator eo)
            {
                SZ oper = null;
                switch (eo)
                {
                    case EnumOperator.Add:
                        oper = new OperationAdd();
                        break;
                    case EnumOperator.Subtraction:
                        oper = new OperationSub();
                        break;
                    case EnumOperator.Multiply:
                        oper = new OperationMul();
                        break;
                    case EnumOperator.Divide:
                        oper = new OperationDiv();
                        break;
                    default:
                        break;
                }
                return oper;
            }
        }
        double currentValue = 0;   //第1个数 
        double numSum = 0;  //第2个数
        private EnumOperator currentOperator; //当前操作符        
        private void ClickNumber(string strNumber)
        {
            tex_result.Text = tex_result.Text + strNumber;
            currentValue = Convert.ToDouble(tex_result.Text);
            tex_display.Text += strNumber;
        }

        private void but7_Click(object sender, EventArgs e)
        {
            ClickNumber(but7.Text);
        }

        private void but8_Click(object sender, EventArgs e)
        {
            ClickNumber(but8.Text);
        }

        private void but9_Click(object sender, EventArgs e)
        {
            ClickNumber(but9.Text);
        }

        private void but4_Click(object sender, EventArgs e)
        {
            ClickNumber(but4.Text);
        }

        private void but5_Click(object sender, EventArgs e)
        {
            ClickNumber(but5.Text);
        }

        private void but6_Click(object sender, EventArgs e)
        {
            ClickNumber(but6.Text);
        }

        private void but1_Click(object sender, EventArgs e)
        {
            ClickNumber(but1.Text);
        }

        private void but2_Click(object sender, EventArgs e)
        {
            ClickNumber(but2.Text);
        }

        private void but3_Click(object sender, EventArgs e)
        {
            ClickNumber(but3.Text);
        }

        private void but0_Click(object sender, EventArgs e)
        {
            ClickNumber(but0.Text);
        }
        //定义一个枚举运算符参数的方法OperatorClick(EnumOperator eo)，里面调用DisplayOperator(EnumOperator eo)方法
        private void OperatorClick(EnumOperator eo)
        {
            if (currentOperator != EnumOperator.None)
            {
                Calculate();//计算
            }
            else
            {
                double.TryParse(tex_result.Text, out numSum);
            }
            DisplayOperator(eo);
            tex_result.Text = "";
            currentOperator = eo;
        }
        //四则运算符按钮的点击事件中调用代表运算符号的枚举
        //+
        private void button12_Click(object sender, EventArgs e)
        {
            OperatorClick(EnumOperator.Add);
        }
        //-
        private void button13_Click(object sender, EventArgs e)
        {
            OperatorClick(EnumOperator.Subtraction);
        }

        //X
        private void button14_Click(object sender, EventArgs e)
        {
            OperatorClick(EnumOperator.Multiply);
        }
        //÷
        private void button15_Click(object sender, EventArgs e)
        {
            OperatorClick(EnumOperator.Divide);
        }
        //根据运算符号来执行四则运算显示的内容 函数 DisplayOperator(EnumOperator op)
        private void DisplayOperator(EnumOperator op)
        {
            switch (op)
            {
                case EnumOperator.None:
                    tex_display.Text = tex_result.Text;
                    tex_display.Text += "";
                    break;
                case EnumOperator.Add:
                    if (tex_result.Text != "")
                    {
                        tex_display.Text = tex_result.Text;
                    }
                    tex_display.Text += "+";
                    break;
                case EnumOperator.Subtraction:
                    if (tex_result.Text != "")
                    {
                        tex_display.Text = tex_result.Text;
                    }
                    tex_display.Text += "-";
                    break;
                case EnumOperator.Multiply:
                    tex_display.Text = tex_result.Text;
                    tex_display.Text += "x";
                    break;
                case EnumOperator.Divide:
                    tex_display.Text = tex_result.Text;
                    tex_display.Text += "/";
                    break;
                default:
                    break;
            }
        }
        //根据运算符和两个数字的计算结果 调用简单工厂模式生成的类 Evaluate()
        private void Calculate()
        {
            SZ oper;

            //根据不同的对象生成不同的类，多态!
            switch (currentOperator)
            {
                case EnumOperator.None:
                    break;
                case EnumOperator.Add:
                    oper = OperatorInput.createOperate(EnumOperator.Add);
                    oper.SZ1 = numSum;
                    oper.SZ2 = currentValue;
                    numSum = oper.GetResult();
                    break;
                case EnumOperator.Subtraction:
                    oper = OperatorInput.createOperate(EnumOperator.Subtraction);
                    oper.SZ1 = numSum;
                    oper.SZ2 = currentValue;
                    numSum = oper.GetResult();
                    break;
                case EnumOperator.Multiply:
                    oper = OperatorInput.createOperate(EnumOperator.Multiply);
                    oper.SZ1 = numSum;
                    oper.SZ2 = currentValue;
                    numSum = oper.GetResult();
                    break;
                case EnumOperator.Divide:
                    if (currentValue != 0)
                    {
                        oper = OperatorInput.createOperate(EnumOperator.Divide);
                        oper.SZ1 = numSum;
                        oper.SZ2 = currentValue;
                        numSum = oper.GetResult();
                    }
                    else
                    {
                        MessageBox.Show("除数不能为零", "请重新输入");
                    }
                    break;
            }
            currentValue = 0;
            currentOperator = EnumOperator.None;
        }

        private void butEqual_Click(object sender, EventArgs e)
        {
            Calculate();
            tex_result.Text = numSum.ToString();
            //防止重复按 = 
            if (tex_result.Text.Length > 1 && tex_result.Text.Substring(tex_result.Text.Length - 1) != "=")
            {
                tex_result.Text += "";
            }
        }

        private void butClear_Click(object sender, EventArgs e)
        {
            currentOperator = EnumOperator.None;
            tex_display.Text = "";
            tex_result.Text = "";
            numSum = 0;
        }
    }
}

结语：

如果一个类中包含敏感性数据，访问需要有对象权限，如果不对这些数据的访问加以限制，后果很严重。所以在编写程序时，要对类的成员使用不同的访问修饰符，从而定义他们的访问权限级别。C#中可以使用类来进行数据封装，这样就可以使数据与方法封装成单一的类，以便于通过方法存取数据。封装性是面向对象编程中最基本的一个特性，在C#中使用封装性时，主要是针对接口和类来说的，对于一些程序中通用的属性、方法通常都封装到接口或者类中，从而提高代码的利用率。

喜欢的请关注、收藏、转发！