面向过程和面向对象之我见

关于面向对象（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了．这个就是所谓的低耦合了吧.由于面向对象的三个特性，使得程序更容易维护，更容易扩展，不像面向过程那样戳襟见肘了．
本文出自 “星小野的微博客-分享” 博客，请务必保留此出处http://yangctoweb.blog.51cto.com/3075514/619975