面向对象

这篇篇文章我主要通过两个例子（计算器和猜拳游戏）来理解面向对象。

使用面向对象编程，关键的是要找出重复的东西，然后把它抽象出来，进行封装。所以，我们先来看下计算器计算的时候，哪些是重复的。重复的可作为属性。

先看计算器的例子。我们先模拟下计算的场景。当用户打开计算器的时候，先需要输入第一个要计算的数字，然后选择运算符，接下来输入第二个要计算的数字，最后得出计算结果。这里面，每次计算的时候，都涉及到要输入的数字，运算符，这三个是变量，所以我们把它们抽象出来，放到一个计算类Calc中。然后在点击计算的时候运算即可。代码如下：

Calc类：

public class Calc
    {
        public double Number1 { get; set; }
        public double Number2 { get; set; }

        public double Calculate(string sign)
        {
            double r;
            switch (sign)
            {
                case "+":
                    r = this.Number1 + this.Number2;
                    break;
                case "-":
                    r = this.Number1 - this.Number2;
                    break;
                case "*":
                    r = this.Number1 * this.Number2;
                    break;
                case "/":
                    r = this.Number1 / this.Number2;
                    break;
                default:
                    throw new Exception("参数错误！");
            }
            return r;
        }
    }

计算方法：

namespace 面线对象实现计算器
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnEquals_Click(object sender, EventArgs e)
        {
            Calc c = new Calc();
            c.Number1 = Convert.ToDouble(txtNumber1.Text);
            c.Number2 = Convert.ToDouble(txtNumber2.Text);

            string sign = cmbSign.Text;

            try
            {
                txtResult.Text = c.Calculate(sign).ToString();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

        }
    }
}

 接下来我们看下面向过程的编程。

public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private void btnEquals_Click(object sender, EventArgs e)
        {
            double n1 = Convert.ToDouble(txtNumber1.Text); 
            double n2 = Convert.ToDouble(txtNumber2.Text);
            try
            {
                string sign = cmbSign.Text;
                double r;
                switch (sign)
                {
                    case "+":
                        r = n1 + n2;
                        break;
                    case "-":
                        r = n1 - n2;
                        break;
                    case "*":
                        r = n1 * n2;
                        break;
                    case "/":
                        r = n1 / n2;
                        break;
                    default:
                        throw new Exception("参数错误！");
                }

                txtResult.Text = r.ToString();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
    }

这样看来面向对象和面向过程好像没什么区别，那为什么还要用面向对象呢？假如，我现在不想用WinForm窗口实现计算器，想改成控制台程序。如果用面向对象编程，只要把Calc类复制过去就实现了整个算法，而面向过程却要把calc中算法全部重写。二者的区别在这里就开始体现了。当然这个计算器还能进一步优化，这个后续再说。

接下来看猜拳游戏。

首先模拟下游戏的场景。当用户点击剪刀时，你出：显示剪刀，电脑随机出，然后比较输赢。这里涉及到的对象有你，电脑。涉及到的属性有，剪刀，石头，布，每个对象都出拳的方法。每个角色都要有个保存出拳结果的属性。既然电脑和你的属性和方法都相同，那能否把这两个对象合并成一个对象呢？最好不要。因为你出拳是用户在界面点击，然后把参数传进去，电脑是随机出拳，可以在方法中随机生成，不传参数，两个方法的参数不一致，分开更好维护。比较输赢的方法不能存在于你和电脑中，因为裁判必须是第三方。为方便判断输赢，我们把出拳结果用数字表示，石头=1，剪刀=2，布=3，用用户出拳减去电脑出拳的结果来表示输赢，很容易得出用户-电脑=-1或者2的时候，玩家赢，用户-电脑=0的时候，表示平局，其余是玩家输。所以，整个猜拳游戏的代码如下：

出拳的枚举：

namespace 猜拳游戏
{
    public enum Fist
    {
        stone=1,
        scissors=2,
        cloth=3
    }
}

玩家类：

namespace 猜拳游戏
{
    public class Person
    {
        public int PFist { get; set; }

        public void ShowFist(int index)
        {
            this.PFist = index;
        }
    }
}

电脑类：

namespace 猜拳游戏
{
    public class Computer
    {
        public int CFist { get; set; }

        public void ShowFist()
        {
            Random rd = new Random();
            int r =rd.Next(1,4);
            this.CFist = r;
        }
    }
}

裁判类：

namespace 猜拳游戏
{
    public class Judgement
    {
        /// <summary>
        /// 猜拳判断输赢 玩家赢=1；平局=0；玩家输=-1
        /// </summary>
        /// <param name="p">玩家</param>
        /// <param name="c">电脑</param>
        /// <returns></returns>
        public int Judge(int p,int c)
        {
            int r;
            if (p - c == -1 || p - c == 2)
            {
                r = 1;
            }
            else if (p - c == 0)
            {
                r = 0;
            }
            else
            {
                r = -1;
            }
            return r;
        }
    }
}

这里要特别提示下：

裁判判断的结果是输赢，这里最好不要直接返回类似“你赢了”之类的信息，返回数字即可，因为用户可能会把“你赢了”改成“You Win ！”等任何其他提示信息。

 窗体类中的代码：

private void btnGuessStone_Click(object sender, EventArgs e)
        {
            Computer c = new Computer();
            c.ShowFist();
            lblComputerResult.Text = c.CFist == (int)Fist.stone ? "石头" : (c.CFist == (int)Fist.scissors ? "剪刀" : "布");
            

            Person p = new Person();
            p.ShowFist((int)Fist.stone);
            lblYouResult.Text = p.PFist == (int)Fist.stone ? "石头" : "";

            Judgement j = new Judgement();
            int r= j.Judge(p.PFist,c.CFist);

            string result = string.Empty;
            //猜拳判断输赢，返回值=0:平局；返回值的绝对值=1:玩家赢;返回值的绝对值=2:玩家输。
            if (r == 0)
            {
                result = "平局，再来一局！";
            }
            if (r==1)
            {
                result = "你赢了！！！";
            }
            if (r == -1)
            {
                result = "你输了！！！";
            }

            lblResult.Text = result;
        }

        private void btnGuessScissors_Click(object sender, EventArgs e)
        {
            Computer c = new Computer();
            c.ShowFist();
            lblComputerResult.Text = c.CFist == (int)Fist.stone ? "石头" : (c.CFist == (int)Fist.scissors ? "剪刀" : "布");
            

            Person p = new Person();
            p.ShowFist((int)Fist.scissors);
            lblYouResult.Text = p.PFist == (int)Fist.scissors ? "剪刀" : "";

            Judgement j = new Judgement();
            int r = j.Judge(p.PFist, c.CFist);

            string result = string.Empty;
            //猜拳判断输赢，返回值=0:平局；=1:玩家赢;-1:玩家输。
            if (r == 0)
            {
                result = "平局，再来一局！";
            }
            if (r == 1)
            {
                result = "你赢了！！！";
            }
            if (r == -1)
            {
                result = "你输了！！！";
            }

            lblResult.Text = result;
        }

        private void btnGuessCloth_Click(object sender, EventArgs e)
        {
            Computer c = new Computer();
            c.ShowFist();
            lblComputerResult.Text = c.CFist == (int)Fist.stone ? "石头" : (c.CFist == (int)Fist.scissors ? "剪刀" : "布");
            

            Person p = new Person();
            p.ShowFist((int)Fist.cloth);
            lblYouResult.Text = p.PFist == (int)Fist.cloth ? "布" : "";

            Judgement j = new Judgement();
            int r = j.Judge(p.PFist, c.CFist);

            string result = string.Empty;
            //猜拳判断输赢，返回值=0:平局；1:玩家输;2:玩家赢。
            if (r == 0)
            {
                result = "平局，再来一局！";
            }
            if (r == 1)
            {
                result = "你赢了！！！";
            }
            if (r == -1)
            {
                result = "你输了！！！";
            }

            lblResult.Text = result;
        }

以上就是面向对象的两个例子，可能表述的不是很完整，后期会反复雕琢，欢迎指正！