C#OOP之深入理解方法-职坐标

C#OOP之深入理解方法

小职 2021-07-26 来源：china_zyb 阅读 865 评论 0

摘要：本文主要是C#OOP之深入理解方法，通过具体的内容向大家展现，希望对大家C#开发的学习有所帮助。

本文主要是C#OOP之深入理解方法，通过具体的内容向大家展现，希望对大家C#开发的学习有所帮助。

C#OOP之深入理解方法

方法深入研究

方法是完成特定功能的代码集。举例来类比一下，比如一台电视，我们开启电视开关之后，我们不需要去理解电视是如何选台、和电视台联系上而播放的步骤，只需要知道会开关电视、选台等就可以了。所以，方法就象一个被封闭的起来的功能操作。

访问修饰符

封装就是使某些信息隐藏起来，但是，对于一定范围的信息仍是可见的。

封装是面向对象三大特性之一。主要是为了一.避免非法数据的访问；二.保证数据的完整性。

我们可以通过访问修饰符来实现封装。C#支持以下如下访问修饰符：

访问修饰符是一些关键字，用于指定声明的成员或类型的可访问性。

【世间万物皆有一定的存在或活动范围，比如你是中国人，那么你的活动范围大部分在中国，如果你要去国外你就得办个护照。再比如你是郑州海洋馆的一只热带鱼，那么别人要来看你，至少要买张门票。世间万物的这种活动和访问范围的机制使世界可以有条不紊的运作。对象或对象成员属性和方法也需要通过某种机制来约束其访问，所以就有了访问修饰符这些东东。】

本节介绍四个访问修饰符：

n public

n protected

n internal

n private

使用这些访问修饰符可指定下列五个可访问性级别：

C#OOP之深入理解方法

切记前面有分号，表示分隔.

项目1：模拟CS游戏中警察的程序

项目背景：对于每位玩过第一人称射击类游戏的朋友来说，CS不能不被反复提起。我们以里面的警察为例，来学习一下访问修饰符符的用处与区别。

解决方案：通过修改访问修饰符，来观察了解访问修饰符的作用范围。

任务1：编写代码，在UltraEdit中编写如下代码，并尝试修改访问修饰符。

功能：实现一款游戏中的一个角色的定义

时间：2015/09/08

作者：张

版本：1.0

usingSystem;
classPolice
{
//属性:Police的成员变量;

private int id; //private:私有的？何为私有：只能被类本身来访问;
private string NickName; //昵称
private string Clothes; //衣服

//行为:成员方法
public void SetInfo() //设置警察信息方法
{
id=888; //这些信息不应该放在Game类里，而应该由Police类的对象来操作；同样访问一个类的成员变量需要，使用对象.成员变量
NickName="菜青虫";
Clothes="绿色迷彩服";
}
public void Display()
{
Console.WriteLine("Id:"+id+"昵称："+NickName+" 衣服："+Clothes); //显示一下信息
}
public void Pao() //成员方法定义：[访问修饰符][返回类型]方法名(参数列表){方法代码}
{
Console.WriteLine("跑@....");
}
public void Zou()
{
Console.WriteLine("走#....");
}
public void Sheji()
{
Console.WriteLine("射击DDDDDD");
}
}
class Game
{
static void Main() //程序的入口处
{
Police kiki=newPolice();
//尝试在此处直接访问类的成员变量
//kiki.id=”007”;kiki.NickName=”金头云”
kiki.SetInfo();
kiki.Display();
kiki.Pao(); //对象名.方法()
kiki.Zou();
kiki.Sheji();
Console.ReadLine();
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.

2.选择文件à保存，以保存该文件，并以Police.cs结束。

3.编译并运行该程序。

4.观察测试不同访问修饰符的区别异同。

方法的定义

方法是类的组成元素，而方法本身又是由很多代码组成的，这些代码也可以包含对方法的调用。事实上，我们在前面的章节已经不止一次用过方法了，例如Main()，我们一直在使用这个方法。方法的定义包括

<访问修饰符><返回类型> 方法名 (形式参数列表)

{

方法体

}

方法命名规则和变量名命名规则一样，方法名应该反映对象行为的含义。

方法的参数列表表示方法接受的处理数据，很多时候事务的行为需要一定的处理数据行为才能正常执行。比如说洗衣机的处理数据是要洗的衣服，动物“吃”方法的处理数据是吃的东西等等。参数列表可以是以下形式：

void eat(); //空参数，不需要参数

void eat(string sPork); //一个形式参数sPork (简称形参)

void eat(string sEgg,int iNum); //两个形式参数（sEgg，iNum）

void eat(string sEgg,int iNum,string sAddress);//三个形式参数（sEgg，iNum，sAddress）"

方法调用：eat(“猪肉”) //注意在此处传入的值”猪肉”为实际参数（简称实参）

方法体指要在方法中执行的代码，它是该方法的详细处理步骤。比如洗衣机的“洗衣”方法里面就包括详细洗衣的步骤，比如左转20圈然后右转20圈、洗衣20分钟、甩干等。

返回类型用关键字return,return语句使用时重点要注意以下几个问题：

n 一个方法中可以出现多个return语句，但只有一个会被执行；

n 返回值的数据类型必须与方法定义返回值数据类型相同；

n 如果方法定义了返回值则必须使用return语句进行返回；

n 当遇到return语句时，方法执行将终止，执行被中断并退出方法；

下面来看一下计算器的程序，看是否仍有需要提高的地方。

功能：实现一个非常简单的计算器，根据客户的要求来进行+ - * /运算;

时间：2015/09/09 ;在第三章Demo\Switch基础上完善

作者：张

版本：2.1.3

using System;
class Calc //Calc类完成的功能是什么？用户输入和计算;输入应该放到客户端来实现，但是此处留个小尾巴.到4.0扩展;
{
//1.成员变量
double x,y; //1.声明两个变量
char op; //op表示操作符; //注意比较：int、char、string的使用，使用哪个更好一些。
//2.成员方法
public void Shuru()
{
Console.WriteLine("请输入第一个操作数：");
x=Convert.ToDouble(Console.ReadLine());
Console.WriteLine("请输入第二个操作数：");
y=Convert.ToDouble(Console.ReadLine());
}
public void Jisuan()
{
Console.WriteLine("请输入您要进行的运算：+ - * /");
op=Convert.ToChar(Console.ReadLine()); //因为op是char型的，需要强制转换;
switch(op)
{
case '+':
Console.WriteLine("和为："+(x+y));
break;
case '-':
Console.WriteLine("差为："+(x-y));
break;
case '*':
Console.WriteLine("积为："+(x*y));
break;
case '/':
if(y==0)
Console.WriteLine("除数不能为0");
else
Console.WriteLine("商为："+(x/y));
break;
default:
Console.WriteLine("错误选择：");
break;
}
}
}
//***************************************客户端类
class CalcGUI
{
static void Main()
{
Calc jisuanqi=new Calc();
jisuanqi.Shuru();
jisuanqi.Jisuan();
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.

该版本的计算器中已经很好的实现了，业务逻辑（计算功能）和界面（客户端:输入）的功能，但是依据OO的原则，应该具有良好的扩展性和复用性，如果在此时，需要增加新的功能则必须再次修改swich中的内容，并且输出功能也应该在客户端实现。因此，此程序仍有完善的必要。下面请大家做项目2，实现业务逻辑与客户端分离的程序。

项目2：计算器：将计算功能和用户输入、输出功能分离

项目背景：剖析计算器，更好的体会OO扩展性、复用性的好处。

解决方案：使用带返回值的方法来解决.

任务1：编写代码

功能：实现计算器;将计算功能和用户输入分离

时间：2015/09/09 星期二第二节课

版本：4.1.1

usingSystem;
classCalc
{
//Calc类的成员变量x,y
private double x,y;
private double result; //再增加一个结果变量

public void ShuRu()
{
//在此接受x,y的值
Console.WriteLine("请输入第一个操作数：");
x=Convert.ToDouble(Console.ReadLine());
Console.WriteLine("请输入第二个操作数：");
y=Convert.ToDouble(Console.ReadLine());
}

public double Jia()
{
result=x+y;
return result;
}
public double Jian()
{
result=x-y;
return result;
}
public double Cheng()
{
result=x*y;
return result;
}
public double Chu()
{
if(y==0)
return 0; //注意此处是有问题的，考虑如何修改
else
{
result=x/y;
return result;
}
}
}
/**********客户端类，即界面类***********/
classClacGUI
{
static void Main()
{
Calc jisuanqi; //jisuanqi=?
jisuanqi=new Calc();

jisuanqi.ShuRu();
Console.WriteLine(“和”+jisuanqi.Jia()); //返回double型的和-->数
Console.WriteLine(“差”+jisuanqi.Jian()); //返回double型的差-->数
Console.WriteLine(“积”+jisuanqi.Cheng()); //返回double型的积-->数
Console.WriteLine(“商”+jisuanqi.Chu()); //返回double型的商-->字符串
//doublex,y; //在Main()方法内,所以说不是ClacGUI的成员变量.叫什么呢？(考察的知识点，为变量的作用域)
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.

任务2：保存程序为Calc4.cs,并编译程序

任务3：运行程序Calc4

任务4：体会本程序与Calc3的区别，考虑改进在何处，是否仍有改进的余地。

任务5：扩充，使用没有返回值的方法，使用返回类型为string的方法如何做？

项目3：计算器：使用带参数的方法

项目背景：剖析计算器，更好的体会OO扩展性、复用性的好处。在原有计算器的基础上增加求平方、求阶乘的功能。

解决方案：使用带返回值及带参数的方法来解决.

任务1：编写代码

功能：实现计算器;将计算功能和用户输入分离

时间：2015/09/09 星期二第二节课

版本：5.1.1

usingSystem;
classCalc
{
private double result; //再增加一个结果变量

public double Jia(double num1,double num2) //加法运算：形参：num1,num2
{
result=num1+num2;
returnresult;
}
publicdouble Jian(double num1,double num2) //减法运算
{
result=num1-num2;
returnresult;
}
publicdouble Cheng(double num1,double num2) //乘法运算
{
result=num1*num2;
returnresult;
}
publicdouble Chu(double num1,double num2) //除法运算
{
result=num1/num2;
returnresult;
}
publicdouble PingFang(double num1)
{
result=num1*num1;
returnresult;
}
publicdouble NciFang(double num1,double num2) //num1:2的num2:5次方
{
result=1; //定义result为1
for(inti=1;i<=num2;i++)
{
result=result*num1;
}
return result;
}
}
/**********客户端类，即界面类***********/
classClacGUI
{
static void Main()
{
Calc jisuanqi; //jisuanqi=?
jisuanqi=new Calc();

double x,y; //x,y为Main()的局部变量
Console.Write("请输入第一个数字：");
x=Convert.ToDouble(Console.ReadLine());
Console.Write("请输入第二个数字：");
y=Convert.ToDouble(Console.ReadLine());

char op; //op为Main()的局部变量，表示操作符
Console.Write("请输入您要进行的运算：+ - * / ^:"); //^：表示求N次方
op=Convert.ToChar(Console.ReadLine());

switch(op)
{
case '+': //加运算
Console.WriteLine(jisuanqi.Jia(x,y));
break;
case '-':
Console.WriteLine(jisuanqi.Jian(x,y));
break;
case '*': //加运算
Console.WriteLine(jisuanqi.Cheng(x,y));
break;
case '/':
if(y==0)
Console.WriteLine("除数不能为0");
else
Console.WriteLine(jisuanqi.Chu(x,y));
break;
case '^':
Console.WriteLine(jisuanqi.NciFang(x,y));
break;
default:
Console.WriteLine("其他无效选择!!!");
break;
}
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.66.67.68.69.70.71.72.73.74.75.76.77.78.79.80.81.82.83.84.

任务2：保存文件，并编译程序

任务3：运行程序

任务4：体会参数在方法中的应用。

方法参数：值参数、引用参数、输出参数

值参数：声明方法时，不带任何修饰符号的是值参数，一个值参数相当于一个局部变量。当使用值参数时，将会分配一个新的存储位置，将实参的值拷贝到这个位置，并且将此拷贝传递给该方法。允许方法将新值传递给值参数，但是这样的赋值只影响实参的副本，而不影响在方法调用时由调用方法给出的实参。被调用方法不会修改内存中实参的值，所以，使用值参数时可以保证实参值是安全的。

简而言之：值参数只能将值带进方法，不能将值带出方法。

案例：二数字交换

//NotSwap.cs
// 值参数不能影响实参的值
usingSystem;
classTest
{
static void NotSwap(int x, int y)
{
Console.WriteLine("进入NotSwap时：x = {0}, y = {1}", x, y);
int temp = x;
x = y;
y = temp;
Console.WriteLine("退出NotSwap时：x = {0}, y = {1}", x, y);
}
static void Main()
{
int i = 1, j = 2;
Console.WriteLine("执行NotSwap前：i = {0}, j = {1}", i, j);
NotSwap(i, j);
Console.WriteLine("执行NotSwap后：i = {0}, j = {1}", i, j);
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.

程序运行效果是值参数的值仅仅在方法体内被改变，而不能影响对应的实参的值。

引用参数：

用ref修饰符声明的参数是引用参数。与值参数不同，引用参数不能创建新的存储位置，用参数表示的存储位置就是在方法调用中，作为实际参数对应的变量所表示的存储位置。

变量在作为引用参数传递之前，必须先明确赋值。

简而言之：引用参数既能将值带进方法，也能将值带出方法。

案例：二数交换

//Swap.cs

// 引用参数会影响实参的值

usingSystem;
classTest
{
static void Swap(ref int x, ref int y)
{
Console.WriteLine("进入Swap时：x = {0}, y = {1}", x, y);
int temp = x;
x = y;
y = temp;
Console.WriteLine("退出Swap时：x = {0}, y = {1}", x, y);
}
static void Main()
{
int i = 1, j = 2;
Console.WriteLine("执行Swap前：i = {0}, j = {1}", i, j);
Swap(ref i, ref j);
Console.WriteLine("执行Swap后：i = {0}, j = {1}", i, j);
}
}
输出参数：
用out修饰的参数是输出参数，其他同ref参数一样，在使用之前无须赋值,必须在方法内完成对象的初始化。
简而言之：输出参数不能将值带进方法，只能将值带出方法。
案例：将路径分解为目录名和文件名的方法SplitPath，需要返回目录名和文件名两个值。
//SplitPath.cs
// 利用输出参数来返回多个值
usingSystem;
classTest
{
static void SplitPath(string path, outstring dir, out string name)
{
int i = path.Length;
while (i > 0)
{
char ch = path[i-1];
if (ch == '\\' || ch == '/'|| ch == ':')
break;
i--;
}
dir = path.Substring(0, i);
name = path.Substring(i);
}
static void Main()
{
string dir, name;
SplitPath("c:\\Windows\\System\\hello.txt",out dir, out name);
Console.WriteLine("目录名: {0}",dir);
Console.WriteLine("文件名: {0}", name);
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.

静态方法与实例方法

static:用来修饰静态成员和静态方法；

没有使用static修饰的成员和方法为实例成员和实例方法；

区别如下：

ü 静态成员、方法属于类，被类的所有实例共享；实例成员、方法属于对象（类的实例），每个对象都有实例成员的不同副本。

ü 静态成员只标识一个存储位置，无论创建了多少个类的实例，它的静态成员在内存中都只占同一块区域；类的实例成员属于类的实例所有，每创建一个类的实例，都在内存中为实例成员开辟一块区域。

ü 静态成员、方法通过类名.运算符来使用；实例成员、方法通过对象名. 运算符来使用。

ü 静态方法只能访问类中的静态成员，而不能使用实例成员。

在前面的Console类的WriteLine、Write等方法就是静态方法，是通过类Console来引用的。

案例：使用账户Account类获取银行信息的静态方法PrintBankInfo

//Account2.cs
// 演示方法的声明和调用

usingSystem;
classAccount
{
private decimal balance;
private string name;
public Account(string name)
{
this.balance = 0;
this.name = name;
Print("开户", 0);
}
public bool Deposit(decimal amount)
{
if (amount <= 0)
return false;
balance += amount;
Print("存入", amount);
return true;
}
public bool Withdraw(decimal amount)
{
if (amount > balance || amount <=0)
return false;
balance -= amount;
Print("取出", amount);
return true;
}
private void Print(string operation,decimal amount)
{
Console.WriteLine("---------------------------");
Console.WriteLine("姓名: {0}", name);
Console.WriteLine("{0}: {1}",operation, amount);
Console.WriteLine("余额: {0}", balance);
Console.WriteLine("---------------------------");
}
public static void PrintBankInfo()
{
Console.WriteLine("---------------------------");
Console.WriteLine(" XYZ银行, 电话: 12345678");
Console.WriteLine("---------------------------");
Console.WriteLine(" 顾客至上服务第一 ");
Console.WriteLine("---------------------------");
}

public static void Main()
{
Account.PrintBankInfo();

Account acc = new Account("张三");
bool succeed = acc.Deposit(100);
if (!succeed)
Console.WriteLine("存款失败！");
succeed = acc.Withdraw(37);
if (!succeed)
Console.WriteLine("取款失败！");
}
}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.