c#的多台方法，大体上和c++的类似，但是有点区别的，我这里刚刚初学，因此把重点记录下。
多态是同一个行为具有多个不同表现形式或形态的能力。
多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。
多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。
在C#中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自Object。
多态就是同一个接口，使用不同的实例而执行不同操作
1、静态多态性
在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C#提供了两种技术来实现静态多态性。分别为：
函数重载和运算符重载，运算符重载后续讨论，这里讨论函数重载。英文是overload，和c++的基本类似。
重载有一点是特别注意：不能通过返回值来重载，只能通过函数的参数进行重载。记得在侯捷的视频中，大师提到过，函数名是一样的，但是编译器其实已经做了标记，在底层函数名称是不一样。
函数重载和c++类似，这里不细谈了。总之一点就通过函数参数来重载的。2、动态多态性
2.1抽象类之abstract
C#允许您使用关键字abstract创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更具体的功能。
c++也有抽象类，只要定义了纯虚函数的都成为抽象类，纯虚函数：virtual void area() = 0; //定义纯虚函数，用来某形状计算面积而且不能实例化，只能被继承后，由派生类来实例化。
c#中，也有类似的特性，并且也更加多的特性，有关抽象类的一些规则：
a、您不能创建一个抽象类的实例。
b、您不能在一个抽象类外部声明一个抽象方法。
c、通过在类定义前面放置关键字sealed，可以将类声明为密封类。当一个类被声明为 sealed时，它不能被继承。抽象类不能被声明为 sealed。
抽象类的实例：
using System;
namespace PolymorphismApplication
{
abstract class Shape //abstract关键字来定义抽象类
{
abstract public int area();
}
class Rectangle: Shape //继承shape抽象类
{
private int length;
private int width;
public Rectangle( int a=0, int b=0)
{
length = a;
width = b;
}
//public int area() //编译错误
public override int area () //重新做派生类中实现area方法，但要是用override“重写”，否则编译错误
{
Console.WriteLine("Rectangle 类的面积：");
return (width * length);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(10, 7); //派生类的实例化
double a = r.area(); //调用派生类的方法
Console.WriteLine("面积： {0}",a);
Console.ReadKey();
}
}
}2.2虚方法之virtual
当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。
c#的动态多态性是通过 抽象类 和 虚方法 实现的。
以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。
虚方法的实例如下：
#define OV //宏定义一定要放在using前面
/*如果注释掉上面的宏定义，那么程序输出的结果是：
执行基类的画图任务
执行基类的画图任务
执行基类的画图任务
说明，使用new的方法是错误的，与设想的功能偏离了。
* 说白了，子类调用Draw()的使用是调用了基类的Draw().并没有实现多态的功能
如果使用上面的宏定义
输出是
画一个长方形
执行基类的画图任务
画一个三角形
执行基类的画图任务
画一个圆形
执行基类的画图任务
请按任意键继续. . .
这样就实现了多态。
*
* 这里强调一次：
* 在子类中用 override 重写父类中用 virtual 申明的虚方法时，
* 实例化父类调用该方法，执行时调用的是子类中重写的方法；
如果在子类中用 new 覆盖父类中用 virtual 申明的虚方法时，
* 实例化父类调用该方法，执行时调用的是父类中的虚方法
*
* override是重写，即将基类的方法在派生类里直接抹去重新写，故而调用的方法就是子类方法；
* 而new只是将基类的方法在派生类里隐藏起来，故而调用的仍旧是基类方法。
*/
using System;
using System.Collections.Generic;
public class Shape
{
//四个语句没用到
//public int X { get; private set; }
//public int Y { get; private set; }
//public int Height { get; set; }
//public int Width { get; set; }
// 虚方法
public virtual void Draw()
{
Console.WriteLine("执行基类的画图任务");
}
}
class Circle : Shape
{
#if (OV)
public override void Draw() //使用override重写
#else
public new void Draw()
#endif
{
Console.WriteLine("画一个圆形");
base.Draw(); //调用基类的放大，使用base
}
}
class Rectangle : Shape
{
#if (OV)
public override void Draw() //使用override重写
#else
public new void Draw()
#endif
{
Console.WriteLine("画一个长方形");
base.Draw(); //调用基类的放大，使用base
}
}
class Triangle : Shape
{
#if (OV)
public override void Draw() //使用override重写
#else
public new void Draw()
#endif
{
Console.WriteLine("画一个三角形");
base.Draw(); //调用基类的放大，使用base
}
}
class Program
{
static void Main(string[] args)
{
// 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
var shapes = new List<Shape>
{
new Rectangle(),
new Triangle(),
new Circle()
};
// 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法
foreach (var shape in shapes)
{
shape.Draw();
}
//Console.WriteLine("按下任意键退出。");
//Console.ReadKey();
}
}在来一个实例：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PolymorphismApplication
{
abstract class Shape //抽象类
{
public abstract int area(); //抽象类的方法，抽象方法只能在抽象类中定义，如果不在抽象类中定义
}
class Rectangle : Shape //继承抽象类
{
private int length;
private int width;
public Rectangle(int a = 0, int b = 0)
{
length = a;
width = b;
}
public override int area() //重写抽象类的方法
{
Console.WriteLine("计算长方形类的面积：");
return (width * length);
}
}
class triangle : Shape //继承抽象类
{
private int baseLine;
private int height;
public triangle(int a = 0, int b = 0)
{
baseLine = a;
height = b;
}
public override int area() //重写抽象类的方法
{
Console.WriteLine("计算三角形类的面积：");
return (2 * baseLine * height / 4);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle r = new Rectangle(10, 7); //实例化长方形
double a = r.area(); //计算长方形的面积
triangle t = new triangle(10, 7); //实例化三角形
double b = t.area(); //计算三角形的面积
Console.WriteLine("长方形面积： {0}, 三角形面积：{1}", a, b);
//Console.ReadKey();
}
}
}
/*
运行结果：
计算长方形类的面积：
计算三角形类的面积：
长方形面积： 70, 三角形面积：35
请按任意键继续. . .
*/
3、总结：
C# 多态性
3.1、多态：一个接口多个功能。
静态多态性：编译时发生函数响应（调用）；
动态多态性：运行时发生函数响应。
静态绑定（早期绑定）：编译时函数和对象的连接机制。两种技术实现静态多态性：函数重载/运算符重载。
3.2、函数重载：在同一范围内对相同函数名有多个定义，可以是参数类型或参数个数的不同，但不许只有返回值类型不同。
运算符重载，这个后续在讨论。
3.3、关键字 abstract 声明抽象类：用于接口部分类的实现（派生类继承抽象类时，实现完成）。抽象类包含抽象方法，抽象方法可被派生类实现。
抽象类规则：
1.不能创建抽象类的实例
2.不能在抽象类外定义抽象方法
3.不能把抽象类声明为sealed（类前带关键字sealed代表该类是密封类，不能被继承）
4.关键字virtual声明虚方法:用于方法在继承类中的实现（在不同的继承类中有不同的实现）。虚方法也可以被直接调用。
抽象类和虚方法共同实现动态多态性。
注：继承类中的重写虚函数需要声明关键字 override，在方法参数传入中写（类名 形参名）例如 public void CallArea(Shape sh)，意思是传入一个 shape 类型的类。
3.4、virtual 和 abstract区别
virtual和abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义。
1.virtual修饰的方法必须有实现（哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。
2.virtual可以被子类重写，而abstract必须被子类重写。
3.如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。
4.无法创建abstract类的实例，只能被继承无法实例化。
5.虚方法也可以被直接调用
3.5、重载和重写区别
重载(overload)是提供了一种机制,相同函数名通过不同的返回值类型以及参数来表来区分的机制。重载在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):
a.方法名必须相同
b.参数列表必须不相同
c.返回值类型可以不相同
重写(override)是用于重写基类的虚方法,这样在派生类中提供一个新的方法。
子类中为满足自己的需要来重复定义某个方法的不同实现，需要用 override 关键字，被重写的方法必须是虚方法，用的是 virtual 关键字。它的特点是(三个相同):
相同的方法名
相同的参数列表
相同的返回值
3.6、抽象方法和虚方法的区别
1.虚方法必须有实现部分，抽象方法没有提供实现部分，抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。这个是特别需要注意的！
2.抽象方法只能在抽象类中声明，虚方法不是。如果类包含抽象方法，那么该类也是抽象的，也必须声明类是抽象的。这一点好c++是一样的。
3.抽象方法必须在派生类中重写，这一点和接口类似，虚方法不需要再派生类中重写。简单说，抽象方法是需要子类去实现的。虚方法是已经实现了的，可以被子类覆盖，也可以不覆盖，取决于需求。
抽象方法和虚方法都可以供派生类重写。