关于面向对象（OO）和面向过程(OOP)，基础的概念就不赘述了，看了一下，大家都是有自己的看法的．
C语言是面向过程的，我们发现要实现某一个需求，比如说＂小米回家＂这个需求，先是下班，然后搭车，在然后到家，C Code Example:
public class GotoHome
    {
        void OffDuty()
        {
            // 添加下班的具体实现代码
            //如判断时间，日期等等
        }
        void GetCar()
        {
            //添加搭车的具体实现代码
            //如招手，上车等等
        }
        void GoHome()
        {
            //添加回家的具体实现代码
            //如拿出钥匙，开门等等
        }
很显然，这个是一个过程，按顺序执行到GoHome()函数时，就可以实现这样的需求了，题目虽然说＂小米回家＂，但是好像不管小米什么事，这个就是面向过程的好处，事先设计好每个函数，也就是小米回家的过程，然后依次调用，就OK了．但是遇到了少则几十，多则几百的繁杂的工序时，难道你还要写几百个函数？？所以就要说道面向对象了．
面向对象就是以事物为中心，什么东西都可以成为对象，一杯咖啡，一个包子等等，前面有位同仁说过，需求是不断变化的，为了满足客户的需求和程序员不被烦死的情况下，使用了面向对象．精力追求代码的最简化，当然是在实现功能的前提下．C# Code Example:
代码有点多，但很容易理解，这个是一个简单工厂模式，实现加，减，乘，除运算．
    /// <summary>
        /// Operation运算类
        /// </summary>
        public class Operation
        {
            private double numA = 0;
            private double numB = 0;

            public double NumberA
            {
                get { return numA; }
                set { numA = value; }
            }
            public double NumberB
            {
                get { return numB; }
                set { numB = value; }
             }
            public virtual double GetResult()  //计算的虚方法
            {
                Double result=0;
                return result;
            }
        }
        /// <summary>
        /// 加法运算类
        /// </summary>
        public class OpertionAdd:Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA + NumberB;
                return result;
            }
        }
        /// <summary>
        /// 减法运算类
        /// </summary>
        public class OpertionSub : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA -NumberB;
                return result;
            }
        }
        /// <summary>
        /// 乘法运算类
        /// </summary>
        public class OpertionMul : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                result = NumberA * NumberB;
                return result;
            }
        }
        /// <summary>
        /// 除法运算类
        /// 除数不能为０
        /// </summary>
        public class OpertionDiv : Operation
        {
            public override double GetResult()
            {
                double result = 0;
                if (NumberB==0)
                {
                    throw new Exception("除数不能为0");
                }
                else
                {
                    result = NumberA / NumberB;
                }
                return result;
            }
        }
        /// <summary>
        /// 运算类工厂
        /// </summary>
        public class OpertionFactory
        {
            public static Operation CreateOperate(string operate)
            {
                Operation opr = null;
                switch (operate)
                {
                    case "+":
                        opr = new OpertionAdd();
                        break;
                    case"-":
                        opr = new OpertionSub();
                        break;
                    case"*":
                        opr = new OpertionMul();
                        break;
                    case"/":
                        opr = new OpertionDiv();
                        break;
                }
                return opr;
            }
        }
        /// <summary>
        /// 客户端代码
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void BtnOk_Click(object sender, EventArgs e)
        {
            Operation opr;
            opr = OpertionFactory.CreateOperate(ListBox1.SelectedItem.Text);
            opr.NumberA = Convert.ToDouble(Txtnum1.Text);
            opr.NumberB = Convert.ToDouble(Txtnum2.Text);
            //opr.NumberA = 4;
            //opr.NumberB = 2;
            double result = opr.GetResult();
            LblMessage.Text = result.ToString();
        }
    }

首先，写一个运算类Operation．得到两个数，将两个数封装，然后有一个GetResult（）的虚方法，然后就是各个算法的子类都要继承:Operation类，继承它后，就重写了GetResult（）方法，这样要修改任何一个算法就于其它的算法没关系，要增加开根或其它算法，只需增加一个运算子类．当然还要在运算类工厂改一下CASE语句就OK了．这个就是所谓的低耦合了吧.由于面向对象的三个特性，使得程序更容易维护，更容易扩展，不像面向过程那样戳襟见肘了．