目录
一、C# 方法详解
C# 中的方法是一段具有签名的代码块，用来实现特定的功能。一个方法一般由以下几个部分组成：
- 访问权限修饰符：指定方法的可见性；
- 返回值类型：指定方法返回值的数据类型；
- 方法名称：调用方法的名称；
- 参数列表：在调用方法时需要传递给方法的参数，参数列表是可选的，可以为空；
- 方法体：其中包含了实现函数功能的若干代码；
1、方法声明
C# 中声明方法的语法格式如下所示：
Access_Specifier Return_Type MethodName(Parameter List)
{
Function_Body
Return_Statement
};说明：
Access_Specifier 为访问权限修饰符；
Return_Type 为返回值类型；
MethodName 为方法名称；
Parameter List 为参数列表；
Function_Body 为方法体；
Return_Statement 为返回语句，用来返回数据。
另外需要注意的是，访问权限修饰符、参数列表和返回语句是可选的，可以省略。
2、方法调用
调用方法，首先需要将方法所在的类实例化，然后通过对象名.方法名()的形式调用指定的方法，这里有几点需要注意：
- 若方法在定义时参数列表中定义了若干参数，那么在调用时也应该在方法名后面的括号中传入相应数量的参数，并且与参数列表中的参数类型一一对应；
- 对于有返回值的方法，在调用方法时可以使用一个变量（可选）来接收方法的返回值，变量的类型要与方法返回值的类型相同；
- 调用类中静态方法（使用 static 修饰的方法），则可以省略实例化对象的过程，直接使用类名.方法名()的形式调用；
3、没有参数和返回值的方法
C# 中，如果方法不需要返回任何内容，则可以在定义方法时使用 void 来修饰返回值类型，示例代码如下：
public void Output()
{
Console.WriteLine("https://www.baidu.com");
}4、有参数但没有返回值的方法
方法可以接收一个或多个数据作为参数，并在方法内部使用或处理传入的参数，示例代码如下：
public void Output(string message)
{
Console.WriteLine(message);
}5、有参数且有返回值的方法
一个方法可以具有零个或任意数量的参数，也可以返回指定的数据。
public string Output(string message)
{
string str = "欢迎访问：" + message;
return str;
}二、C# 值传递、引用传递、输出传递
先介绍下形式参数和实际参数的概念：
- 形式参数：指的是参数列表中定义的参数，简称形参。可以将它看作变量的名称，它没有具体的值，只是用来接收方法调用时传递过来的数据；
- 实际参数：指的是传递给方法的参数，简称实参。可以将它看作变量的值，用来为形参赋值；
1、值传递
在C# 中，值传递是将参数传递给方法的默认方式。值传递的本质是将实参的副本（也就是将实参的值复制一份）传递给方法。
当调用方法时，使用实参的副本为每个形参赋值，并为每个形参创建一个新的存储位置。由于实参和形参使用的是两个不同内存位置中的值，所以当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。
举例：
// 如何使用值传递的方式将参数传递给方法:
class Demo
{
static void Main(string[] args){
int val = 10;
Console.WriteLine("调用方法之前：{0}", val);
Console.ReadKey();
Demo Obj = new Demo();
Obj.Func(val);
Console.WriteLine("调用方法之后：{0}", val);
Console.ReadKey();
}
public void Func(int val){
val *= val;
Console.WriteLine("方法内部的值：{0}", val);
Console.ReadKey();
}
}
// 通过运行结果可以看出，尽管我们在方法内部对形参 val 的值进行了修改，但是并不会影响方法外面实参 val 的值。2、引用传递
与值传递不同的是，使用引用传递的形式传递参数时，并不会为形参创建新的内存地址，而是复制参数的内存位置并传递给形式参数，与实参共同指向相同的内存地址。正因为如此，当修改形参的值时，实参的值也会被修改。
在 C# 中，需要使用 ref 关键字来使用引用传递，下面通过示例来演示一下：
class Program
{
static void Main(string[] args)
{
int val = 10;
Console.WriteLine("调用方法之前：{0}", val);
Console.ReadKey();
Program Obj = new Program();
Obj.Func(ref val);
Console.WriteLine("调用方法之后：{0}", val);
Console.ReadKey();
}
public void Func(ref int val)
{
val *= val;
Console.WriteLine("方法内部的值：{0}", val);
Console.ReadKey();
}
}3、输出传递
在方法中，使用 return 语句可以返回一个值，使用输出传递则可以一次性返回多个值。输出传递与引用传递相似，不同之处在于输出传递是将数据从方法中传出来而不是传到方法中。
在 C# 中，需要使用 out 关键字来使用输出传递，下面通过示例来演示一下：
class Program
{
static void Main(string[] args)
{
int val = 10;
Console.WriteLine("调用方法之前：{0}", val);
Console.ReadKey();
Program Obj = new Program();
Obj.Func(out val);
Console.WriteLine("调用方法之后：{0}", val);
Console.ReadKey();
}
public void Func(out int x)
{
int temp = 11;
x = temp;
x *= x;
Console.WriteLine("方法内部的值：{0}", x);
Console.ReadKey();
}
}
// 运行结果如下:
调用函数之前 val 的值：10
调用函数之后 val 的值：121在使用输出传递时，也可以不为实参赋值，如下例所示：
class Program
{
static void Main(string[] args)
{
Program Obj = new Program();
Obj.GetValues(out int a, out int b);
Console.WriteLine("调用方法之后 a 的值：{0}", a);
Console.WriteLine("调用方法之后 b 的值：{0}", b);
Console.ReadKey();
}
public void GetValues(out int x, out int y)
{
Console.WriteLine("请输入第一个值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第二个值： ");
y = Convert.ToInt32(Console.ReadLine());
}
}三、C# 参数数组
在某些情况下，我们定义方法时可能并不能提前确定参数的数量，这时可以使用 C# 提供的参数数组，参数数组通常用于为方法传递未知数量的参数。
若要使用参数数组，则需要使用 params 关键字，语法格式如下：
访问权限修饰符 返回值类型 方法名(params 类型名称[] 数组名称)
使用参数数组时，既可以直接为方法传递一个数组作为参数，也可以使用方法名(参数1, 参数2, ..., 参数n)的形式传递若干个具体的值作为参数。
举例：
class Program
{
static void Main(string[] args)
{
Program Obj = new Program();
string str = Obj.GetSum(1, 3, 5, 7, 9);
Console.WriteLine(str);
Console.ReadKey();
int[] arr = { 2, 4, 6, 8, 10 };
string str2 = Obj.GetSum(arr);
Console.WriteLine(str2);
Console.ReadKey();
}
public string GetSum(params int[] arr)
{
int sum = 0;
string str = "";
foreach (int i in arr)
{
sum += i;
str += "+ " + i + " ";
}
str = str.Trim('+');
str += "= " + sum;
return str;
}
}四、C# 封装
C# 是一门面向对象的编程语言，面向对象编程语言有三大特性，即封装、继承和多态。所谓封装，就是将一个或多个项目（方法）集合在一个单元中，这个单元称之为类。我们可以根据需要通过访问权限修饰符来指定类中成员的范围和可见性。
C# 中的访问权限修饰符有以下几种：
1、public
公共的，所有对象都可以访问，有时需要引用命名空间。
类中使用 public 访问权限修饰符修饰的成员变量或成员方法可以暴露给其他的方法或对象，我们可以从类的外部访问类中的公共成员。
举例：
class Demo
{
static void Main(string[] args){
Rectangle Obj = new Rectangle();
Obj.width = 5.5;
Obj.length = 3;
Obj.Display();
Console.ReadLine();
}
}
class Rectangle
{
// 成员变量
public double width, length;
public double GetArea(){
return width * length;
}
public void Display(){
Console.WriteLine("长方形的长：{0}", length);
Console.WriteLine("长方形的宽：{0}", width);
Console.WriteLine("长方形的面积：{0}", GetArea());
}
}2、internal
内部的，同一个程序集的对象可以访问，程序集就是命名空间。
类中使用 internal 访问权限修饰符修饰的成员变量或成员方法可以在当前程序集中的其他函数或对象中使用。换句话说就是，任何使用 internal 修饰的成员都可以被同一命名空间下的任何类或方法访问。
举例：
using System;
namespace MyApp
{
class Demo
{
static void Main(string[] args){
Rectangle Obj = new Rectangle();
Obj.length = 33.3;
Obj.width = 22.2;
Obj.Display();
Console.ReadLine();
}
}
class Rectangle
{
// 成员变量
internal double width, length;
// 成员方法（默认是私有的）
double GetArea(){
return width * length;
}
public void Display(){
Console.WriteLine("长方形的长：{0}", length);
Console.WriteLine("长方形的宽：{0}", width);
Console.WriteLine("长方形的面积：{0}", GetArea());
}
}
}3、protected
受保护的，类的内部或类的子类中可以访问。
类中使用 protected 访问权限修饰符修饰的成员变量或成员方法可以在其子类中访问。也就是说基类（父类）中使用 protected 访问权限修饰符修饰的成员变量或成员方法可以在其子类中访问，这样有助于实现继承。
4、private
私有的，只有在类的内部才可以访问。
类中使用 private 访问权限修饰符修饰的成员变量或成员方法不能在其它方法或对象中访问。即使是类的实例也不能访问这个类中的私有成员，只有同属一个类的方法才可以访问这个类的私有成员。
举例：
using System;
namespace MyApp
{
class Demo
{
static void Main(string[] args){
Rectangle Obj = new Rectangle();
Obj.AcceptDetails();
Obj.Display();
Console.ReadLine();
}
}
class Rectangle
{
// 成员变量
private double width, length;
public void AcceptDetails(){
Console.WriteLine("请输入长方形的长度: ");
length = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("请输入长方形的宽度: ");
width = Convert.ToDouble(Console.ReadLine());
}
public double GetArea(){
return width * length;
}
public void Display(){
Console.WriteLine("长方形的长：{0}", length);
Console.WriteLine("长方形的宽：{0}", width);
Console.WriteLine("长方形的面积：{0}", GetArea());
}
}
}5、protected internal
protected 和 internal 的并集，符合任意一条都可以访问。
类中使用 protected internal 访问权限修饰符修饰的成员可以在本类、派生类或者包含该类（使用 using 引入）的程序集中访问，在实现继承时也使用此方法。
五、C# 继承
在创建一个新类时，我们可以让这个新定义的类继承一个已有的类。通过继承可以在创建新类时重用、扩展或修改被继承类中定义的成员。被继承的类称为 "基类（父类）"，继承基类的类称为 "派生类（子类）"。
C# 中只支持单继承，也就是说一个派生类只能继承一个基类，但是继承是可以传递的。例如: ClassC 继承了 ClassB，而 ClassB 继承了 ClassA，那么 ClassC 将继承 ClassB 和 ClassA 中的所有成员。
1、基类和派生类
要让一个类继承另一个类需要使用冒号 : 来表示，如：
class Program
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
r.SetWidth(3);
r.SetHeight(4);
int area = r.GetArea();
Console.WriteLine("长方形的面积为：{0}", area);
Console.ReadKey();
}
}
// 基类
class Shape
{
protected int width, height;
public void SetWidth(int w)
{
width = w;
}
public void SetHeight(int h)
{
height = h;
}
}
// 派生类
class Rectangle : Shape
{
public int GetArea()
{
return width * height;
}
}2、多重继承
C# 不支持多重继承，但是可以借助接口来实现多重继承。如下所示：
using System;
namespace MyFirstConsoleApp
{
class Program
{
static void Main(string[] args)
{
Rectangle r = new Rectangle();
r.SetWidth(3);
r.SetHeight(4);
int girth = r.GetGirth();
int area = r.GetArea();
Console.WriteLine("长方形的面积为：{0}", area);
Console.WriteLine("长方形的周长为：{0}", girth);
Console.ReadKey();
}
}
// 定义接口
public interface IPerimeter
{
int GetGirth();
}
// 基类
class Shape
{
protected int width, height;
public void SetWidth(int w)
{
width = w;
}
public void SetHeight(int h)
{
height = h;
}
}
// 派生类
class Rectangle : Shape, IPerimeter
{
// 计算面积
public int GetArea()
{
return width * height;
}
// 计算周长
public int GetGirth()
{
return (width + height) * 2;
}
}
}
六、C# 多态
多态（Polymorphism）是一个希腊词，指 "多种形态"。在 C# 中具有两种类型的多态：
1、编译时多态
在编译期间将方法与对象链接的机制称为早期绑定，也称为静态绑定。C# 提供了两种技术来实现编译时多态，即方法重载和运算符重载。
（1）方法重载
在同一个作用域中，可以定义多个同名方法，但是这些方法之间必须有所差异。比如：参数个数不同、参数类型不同等等，返回值类型不同除外。
举例：
class Demo
{
void print(int i){
Console.WriteLine("打印 int 类型的数据：{0}", i);
}
void print(double d){
Console.WriteLine("打印 double 类型的数据：{0}", d);
}
void print(string s){
Console.WriteLine("打印 string 类型的数据：{0}", s);
}
static void Main(string[] args)
{
Demo p = new Demo();
p.print(123);
p.print(3.1415926);
p.print("百度一下");
}
}（2）运算符重载
参见【七、C# 运算符重载】
2、运行时多态
C# 使用 abstract 关键字来创建抽象类，抽象类用于实现部分接口。另外，抽象类包含抽象方法，可以在派生类中实现。
下面列举了一些有关抽象类的规则：
- 抽象类不能实例化，不能在一个抽象类外部声明抽象方法；
- 通过在类定义时使用 sealed 关键字，可以将类声明为密封类，密封类不能被继承，因此抽象类中不能声明密封类。
举例：
using System;
namespace MyApp
{
abstract class Shape
{
public abstract int area();
}
class Rectangle : Shape
{
private int width, height;
public Rectangle(int w, int h)
{
this.width = w;
this.height = h;
}
public override int area()
{
return width * height;
}
}
class Demo
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(12,15);
double a = r.area();
Console.WriteLine("长方形的面积为： {0}", a);
Console.ReadKey();
}
}
}七、C# 运算符重载
C# 支持运算符重载，所谓运算符重载就是我们可以使用自定义类型来重新定义 C# 中大多数运算符的功能。
运算符重载需要通过 operator 关键字后跟运算符的形式来定义。我们可以将被重新定义的运算符看作是具有特殊名称的方法，与其他方法一样，该方法也有返回值类型和参数列表。
1、可重载与不可重载的运算符
下表提供了 C# 运算符可重载性的相关信息：
| 运算符 | 可重载性 |
|---|---|
| +、-、!、~、++、-- | 这些一元运算符可以进行重载 |
| +、-、*、/、%、&、|、^、<<、>>、=、!=、<、>、<=、>= | 这些二元运算符可以进行重载（红色标记的运算符必须成对重载） |
| &&、|| | 无法重载逻辑运算符 |
| (type)var_name | 强制类型转换运算符不能重载 |
| +=、-=、*=、/=、%=、&=、|=、^=、<<=、>>= | 复合赋值运算符不能显式重载。 但在重载二元运算符时，也会隐式重载相应的复合赋值运算符，例如重载了+运算符也会隐式的重载+= |
| ^、=、.、?.、? : 、??、??=、..、->、=>、as、await、checked、unchecked、default、delegate、is、nameof、new、sizeof、stackalloc、switch、typeof | 这些运算符无法进行重载 |
举例：
using System;
namespace MyFirstConsoleApp
{
class Program
{
static void Main(string[] args)
{
// 声明 Box1，类型为 Box
Box Box1 = new Box();
// 声明 Box2，类型为 Box
Box Box2 = new Box();
// 声明 Box3，类型为 Box
Box Box3;
// 声明 Box4，类型为 Box
Box Box4;
// 体积
double volume;
// Box1 详述
Box1.SetLength(6.0);
Box1.SetBreadth(7.0);
Box1.SetHeight(5.0);
// Box2 详述
Box2.SetLength(12.0);
Box2.SetBreadth(13.0);
Box2.SetHeight(10.0);
// 使用重载的 ToString() 显示两个盒子
Console.WriteLine("Box1： {0}", Box1.ToString());
Console.WriteLine("Box2： {0}", Box2.ToString());
// Box1 的体积
volume = Box1.GetVolume();
Console.WriteLine("Box1 的体积： {0}", volume);
// Box2 的体积
volume = Box2.GetVolume();
Console.WriteLine("Box2 的体积： {0}", volume);
// 把两个对象相加
Box3 = Box1 + Box2;
Console.WriteLine("Box3： {0}", Box3.ToString());
// Box3 的体积
volume = Box3.GetVolume();
Console.WriteLine("Box3 的体积： {0}", volume);
//comparing the boxes
if (Box1 > Box2)
Console.WriteLine("Box1 大于 Box2");
else
Console.WriteLine("Box1 不大于 Box2");
if (Box1 < Box2)
Console.WriteLine("Box1 小于 Box2");
else
Console.WriteLine("Box1 不小于 Box2");
if (Box1 >= Box2)
Console.WriteLine("Box1 大于等于 Box2");
else
Console.WriteLine("Box1 不大于等于 Box2");
if (Box1 <= Box2)
Console.WriteLine("Box1 小于等于 Box2");
else
Console.WriteLine("Box1 不小于等于 Box2");
if (Box1 != Box2)
Console.WriteLine("Box1 不等于 Box2");
else
Console.WriteLine("Box1 等于 Box2");
Box4 = Box3;
if (Box3 == Box4)
Console.WriteLine("Box3 等于 Box4");
else
Console.WriteLine("Box3 不等于 Box4");
Console.ReadKey();
}
}
class Box
{
// 长度
private double length;
// 宽度
private double breadth;
// 高度
private double height;
public void SetLength(double length)
{
this.length = length;
}
public void SetBreadth(double breadth)
{
this.breadth = breadth;
}
public void SetHeight(double height)
{
this.height = height;
}
public double GetVolume()
{
return length * breadth * height;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box a, Box b)
{
Box tmp = new Box();
tmp.length = a.length + b.length;
tmp.breadth = a.breadth + b.breadth;
tmp.height = a.height + b.height;
return tmp;
}
// 重载 == 运算符
public static bool operator== (Box lhs, Box rhs)
{
bool status = false;
if (lhs.length == rhs.length && lhs.height == rhs.height && lhs.breadth == rhs.breadth)
{
status = true;
}
return status;
}
// 重载 != 运算符
public static bool operator!= (Box lhs, Box rhs)
{
bool status = false;
if (lhs.length != rhs.length || lhs.height != rhs.height || lhs.breadth != rhs.breadth)
{
status = true;
}
return status;
}
// 重载 > 运算符
public static bool operator> (Box lhs, Box rhs)
{
bool status = false;
if (lhs.length > rhs.length && lhs.height > rhs.height && lhs.breadth > rhs.breadth)
{
status = true;
}
return status;
}
// 重载 < 运算符
public static bool operator< (Box lhs, Box rhs)
{
bool status = false;
if (lhs.length < rhs.length && lhs.height < rhs.height && lhs.breadth < rhs.breadth)
{
status = true;
}
return status;
}
// 重载 <= 运算符
public static bool operator <=(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length <= rhs.length && lhs.height <= rhs.height && lhs.breadth <= rhs.breadth)
{
status = true;
}
return status;
}
// 重载 >= 运算符
public static bool operator >=(Box lhs, Box rhs)
{
bool status = false;
if (lhs.length >= rhs.length && lhs.height >= rhs.height && lhs.breadth >= rhs.breadth)
{
status = true;
}
return status;
}
public override bool Equals(object o)
{
if (o == null)
{
return false;
}
if (GetType() != o.GetType())
{
return false;
}
return true;
}
public override int GetHashCode()
{
return base.GetHashCode();
}
public override string ToString()
{
return String.Format("({0}, {1}, {2})", length, breadth, height);
}
}
}
八、C# 接口
接口可以看作是一个约定，它本身并不实现任何功能，只是定义了实现该接口的类或结构体必须实现的功能。
抽象类在某种程度上与接口类似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。
接口的特点如下所示：
- 接口是一个引用类型，通过接口可以实现多重继承；
- 接口中只能声明"抽象"成员，所以不能直接对接口进行实例化；
- 接口中可以包含方法、属性、事件、索引器等成员；
- 接口名称一般习惯使用字母“I”作为开头（不是必须的，不这样声明也可以）；
- 接口中成员的访问权限默认为 public，所以我们在定义接口时不用再为接口成员指定任何访问权限修饰符，否则编译器会报错；
- 在声明接口成员的时候，不能为接口成员编写具体的可执行代码。也就是说，定义成员时指明成员的名称和参数就可以了；
- 接口一旦被实现（被一个类继承），派生类就必须实现接口中的所有成员，除非派生类本身也是抽象类。
1、声明接口
在 C# 中声明接口需要使用 interface 关键字，语法结构如下所示：
public interface InterfaceName
{
returnType funcName1(type parameterList);
returnType funcName2(type parameterList);
... ...
}说明：
InterfaceName 为接口名称；
returnType 为返回值类型；
funcName 为成员函数的名称；
parameterList 为参数列表；
举例：
class Program
{
static void Main(string[] args)
{
Website web = new Website();
web.SetValue("百度一下", "https://www.baidu.com");
web.DisPlay();
Console.ReadKey();
}
}
public interface IWebsite
{
void SetValue(string str1, string str2);
void DisPlay();
}
public class Website : IWebsite
{
public string name, url;
public void SetValue(string n, string u)
{
this.name = n;
this.url = u;
}
public void DisPlay()
{
Console.WriteLine("{0} {1}", name, url);
}
}2、接口继承
在 C# 中，一个接口可以继承另一个接口。例如：可以使用接口 1 继承接口 2，当用某个类来实现接口 1 时，必须同时实现接口 1 和接口 2 中的所有成员，如下所示：
class Program : IMyInterface
{
static void Main(string[] args)
{
Program p = new Program();
p.ParentInterfaceMethod();
p.MethodToImplement();
Console.ReadKey();
}
public void ParentInterfaceMethod()
{
Console.WriteLine("实现 IParentInterface 接口中的 ParentInterfaceMethod 函数");
}
public void MethodToImplement()
{
Console.WriteLine("实现 IMyInterface 接口中的 MethodToImplement 函数");
}
}
public interface IParentInterface
{
void ParentInterfaceMethod();
}
public interface IMyInterface : IParentInterface
{
void MethodToImplement();
}
1955
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
