C#面向对象(OOP)入门—第一天—多态和继承（方法重载）
面向对象是什么
面向对象是一种基于对象的编程方法，它取代了仅仅依靠方法和流程的编程方式。面向对象的编程语言中，对象（object）其实就是指特定类型、或某个类的实例。面向对象使得编程人员更容易组织和管理整个软件的程序。对象之间的独立性使得我们更容易更新和更改程序。对于大型程序则更加易读和易管理。
面向对象包含哪些内容
- 数据抽象（Data Absraction）:数据抽象的概念是逻辑实现的内部和多余的细节对用户隐藏。用户可以使用一个类所允许使用的任何数据和方法，而不必要明白它是如何创建或者它背后有多么复杂。举一个现实的例子，就是开车过程中，我们可以通过换挡杆来换档，然而我们比不要知道他是如何换挡的，比如换挡过程中齿轮箱等部件是如何动作的，我们只需要根据自己的需要来切换档位就行。
- 继承（Inheritance）：继承是面向对象中最受欢迎的概念，继承让开发者可以实现代码重用。例如，我们在一个类里面实现了一个有特定逻辑功能的函数，我们可以用这个类派生一个新的类，然后我们不必要重新写这个函数，在派生类中可以直接使用。
- 数据封装（Data Encapsulation）：将类里面的成员函数和成员数据封装进一个单独的模块叫做封装，数据或函数的可见性可以由访问修饰符来控制。
- 消息通讯（Message Communication）：指当一个对象调用一个类的方法去执行的时候，消息的通讯手段。
方法重载（编译时多态）
public class Overload
{
public void DisplayOverload(int a){
System.Console.WriteLine("DisplayOverload " + a);
}
public void DisplayOverload(string a){
System.Console.WriteLine("DisplayOverload " + a);
}
public void DisplayOverload(string a, int b){
System.Console.WriteLine("DisplayOverload " + a + b);
}
}
类似上面的代码，3个函数拥有相同的名字，但是参数类型不同。这就是方法重载。
知识点：在C#中，函数签名（识别一个函数的依据）包括函数的名称以及函数的参数（包括参数数量和参数数据类型，参数的类型）。函数的返回值不是，函数的修饰关键字（比如static）也不是。参数的类型指的是ref或者out的参数。（例如 int a 和 ref int a不同，但是注意 ref int a 和 out int a 相同）。
参数数组参数在多态中的作用
一个方法被调用过程中，参数的类型有以下几种：
- 传递值
- 传递引用（ref）
- 作为输出参数（out）（其实也是一种引用的传递）
- 采用参数数组（params）
当我们传递N个（未知）参数给某个方法的时候，我们可以用params关键字。
知识点：params关键字只能在方法的最后一个参数,并且数组不能是多维的。
例如如下定义是错误的：
private void DisplayOverload(int a, params string[] parameterArray, int b) { }
知识点：当有个params的参数在最后一个，但是倒数第二个参数的类型和最后一个相同，则传递参数中，符合类型的第一个会给值，剩余的给后面的参数数组（例如 []和[][]可以，而[,] 不可以），并且params关键字不能和ref或out组合使用。
例如：
public class Overload
{
public void Display()
{
DisplayOverload(100, 200, 300); //100会传递给参数a，200和300传递给parameterArray
DisplayOverload(200, 100); //200传递给参数a，100传递给parameterArray
DisplayOverload(200); //200传递给参数a
}
private void DisplayOverload(int a, params int[] parameterArray)
{
foreach (var i in parameterArray)
Console.WriteLine(i + " " + a);
}
}
这种情况也是错误的
public class Overload
{
public void Display()
{
string [] names = {"Akhil","Arsh"};
DisplayOverload(2, names, "Ekta"); //当调用函数时，编译器会试图将names和 "Ekta"组合为一个字符串数组，但是names不是string而是string[]类型，所以会报错
}
private void DisplayOverload(int a, params string[] parameterArray)
{
foreach (var str in parameterArray)
Console.WriteLine(str + " " + a);
}
}
对于在传递数组参数后，改变其值会发生什么举如下两个例子：
例子1：
public class Overload
{
public void Display()
{
int[] numbers = {10, 20, 30};
DisplayOverload(40, numbers);
Console.WriteLine(numbers[1]);
}
private void DisplayOverload(int a, params int[] parameterArray)
{
parameterArray[1] = 1000;
}
}
class Program
{
static void Main(string[] args)
{
Overload overload = new Overload();
overload.Display();
Console.ReadKey();
}
}
//输出结果是1000
例子2：
public class Overload
{
public void Display()
{
int number = 102;
DisplayOverload(200, 1000, number, 200);
Console.WriteLine(number);
}
private void DisplayOverload(int a, params int[] parameterArray)
{
parameterArray[1] = 3000;
}
}
class Program
{
static void Main(string[] args)
{
Overload overload = new Overload();
overload.Display();
Console.ReadKey();
}
}
//输出结果是102
例子1中的数组传递到函数里面，在函数更改值对应也更改了原数组的值。（我认为是传递的数组的地址）；但是对于例子2，不得不新建一个数组来存放各个参数组成的新数组，然后传递到调用的函数里，当对其更改值时，其实更改的是新数组对应的值，而这个函数对number的值一无所知，跟别提去更改了。
另一种重载的情况
public class Overload
{
public void Display()
{
DisplayOverload(200);
DisplayOverload(200, 300);
DisplayOverload(200, 300, 500, 600);
}
private void DisplayOverload(int x, int y)
{
Console.WriteLine("The two integers " + x + " " + y);
}
private void DisplayOverload(params int[] parameterArray)
{
Console.WriteLine("parameterArray");
}
}
class Program
{
static void Main(string[] args)
{
Overload overload = new Overload();
overload.Display();
Console.ReadKey();
}
}
/*
输出是：
parameterArray
The two integers 200 300
parameterArray
*/
第一个和第三个调用没有问题，只能调用带数组的参数。但是对于第二种我不太理解，原文作者解释说，C#很聪明，他对params参数不太认可，就像不是自己的亲生孩子一样，所以作为第二选择，两个int参数正好有匹配的函数来调用，所以这样输出。作者虽然感情化的描述了，但是可以理解，因为确实就是这样的机制。要想真正的明白缘由，或许还要查阅一些资料才能明白，暂时搁置这个问题吧。
好吧，一个更有趣的例子：
public class Overload
{
public static void Display(params object[] objectParamArray)
{
foreach (object obj in objectParamArray)
{
Console.Write(obj.GetType().FullName + " ");
}
Console.WriteLine();
}
}
class Program
{
static void Main(string[] args)
{
object[] objArray = { 100, "Akhil", 200.300 };
object obj = objArray;
Overload.Display(objArray);
Overload.Display((object)objArray);
Overload.Display(obj);
Overload.Display((object[])obj);
Console.ReadKey();
}
}
/*
输出结果是：
System.Int32 System.String System.Double
System.Object[]
System.Object[]
System.Int32 System.String System.Double
*/
Display函数是输出数组内每个成员的类型。第一个调用没有问题，第二个调用与第三个调用等价，传递过去的其实是一个object对象（注意这不是装箱，装箱时值类型转换为object，而数组是引用类型），这时，首先是将object转换为object[]但是不存在这样的默认转换，所以只能创建一个object[]来存放obj，而obj的类型就是object[]，所以输出System.Object[]。第四个调用，做了强制的转换，从object到object[]，所以跟第一个相同。
总结：
这篇文章主要讲了编译时多态，也叫作前期绑定或者方法重载。并列举了方法重载的各种情形，以及params参数在重载中的特殊用途。
- C# 通过其参数而不是由它的名字来区别一个方法。
- 方法返回值和参数类型绝不是方法签名的一部分，如果方法的名称相同。所以这不是多态性。
- 修饰符（如static）不是方法签名的一部分。
- 方法的签名包括其名称、 形参的数量和类型。一个函数的返回类型不是签名的一部分。两种方法不能具有相同的签名，并且成员也不能有同名的成员。
- 参数名称应是唯一的。我们也可以不有一个参数名称和声明的变量名称相同的功能相同。
- 如果通过值传递，变量的值传递过去，如果通过 ref 和 out，引用的地址传递过去。
- 这 params 关键字只能应用于方法的最后一个参数。因此n 个数量的参数只可以在最后。
- C# 是很聪明地承认如果倒数第二个参数，参数有相同的数据类型。
- 参数数组必须是一维数组。
注明：原文地址：https://codeteddy.com/2014/05/11/diving-in-oop-part-1-polymorphism-and-inheritanceearly-bindingcompile-time-polymorphism/
我只是在作者基础上进行了翻译以及总结，并加了一点自己的理解，希望对大家有帮助。
如有错误，敬请指证。
