什么是多态：
父类的一些成员，子类继承周去重写从而实现不同的功能。
多态的风雷
多态分为两种，一种是编译时的多态，一种是运行时的多态。
编译时多态：编译时的多态性是通过重载来实现的。
编译时的多态性：编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
运行时的多态性：运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中运行时的多态性是通过覆写虚成员实现。
多态的实现
重载（overload）
重载指的是同一个累中有两个或者多个名字但是参数不同的方法。
public void Calculate()
{
// do the calculation here
}
public void Calculate(int num)
{
// do the calculation here
}
运行时多态： 重写
重写有两种， 一种是override修饰符， 另一种使用new 修饰符
重新（override）是对父类中的虚函数（virtual method）或抽象函数的“覆盖”。
/// <summary>
/// 动物类(父类)
/// </summary>
class Animal
{
/// <summary>
/// 名字
/// 说明：类和子类可访问
/// </summary>
protected string name;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="name"></param>
public Animal(string name)
{
this.name=name;
}
/// <summary>
/// 名字(虚属性)
/// </summary>
public virtual string MyName
{
get { return this.name; }
}
/// <summary>
/// 吃（虚方法）
/// </summary>
public virtual void Eat()
{
Console.WriteLine("我会吃!");
}
/// <summary>
/// 叫（虚方法）
/// </summary>
public virtual void Shout()
{
Console.WriteLine("我会叫！");
}
}
/// <summary>
/// 狗（子类）
/// </summary>
class Dog:Animal
{
string myName;
public Dog(string name): base(name)
{
myName = name;
}
/// <summary>
/// 名字(重写父类属性)
/// </summary>
public override string MyName
{
get { return "我是：狗狗，我叫："+this.name; }
}
/// <summary>
/// 吃(重写父类虚方法)
/// </summary>
public override void Eat()
{
Console.WriteLine("我喜欢吃肉!");
}
/// <summary>
/// 叫（重写父类方法）
/// </summary>
public override void Shout()
{
Console.WriteLine("汪!汪!汪！");
}
}
/// <summary>
/// 猫（子类）
/// </summary>
class Cat : Animal
{
string myName;
public Cat(string name)
: base(name)
{
myName = name;
}
/// <summary>
/// 名字(重写父类属性)
/// </summary>
public override string MyName
{
get { return "我是：猫咪，我叫：" + this.name; }
}
/// <summary>
/// 吃(重写父类虚方法)
/// </summary>
public override void Eat()
{
Console.WriteLine("我喜欢吃鱼!");
}
/// <summary>
/// 叫（重写父类方法）
/// </summary>
public override void Shout()
{
Console.WriteLine("喵!喵!喵！");
}
}
/// <summary>
/// 羊（子类）
/// </summary>
class Sheep : Animal
{
string myName;
public Sheep(string name)
: base(name)
{
myName = name;
}
/// <summary>
/// 名字(重写父类属性)
/// </summary>
public override string MyName
{
get { return "我是：羊羊，我叫：" + this.name; }
}
/// <summary>
/// 吃(重写父类虚方法)
/// </summary>
public override void Eat()
{
Console.WriteLine("我喜欢吃草!");
}
/// <summary>
/// 叫（重写父类方法）
/// </summary>
public override void Shout()
{
Console.WriteLine("咩!咩!咩！");
}
}
重写（new）
new：覆盖指的是不同类中有两个或以上的返回类型，方法名，参数都相同，但是方法体不同的方法。
/// <summary>
/// 动物类(父类)
/// </summary>
class Animal
{
/// <summary>
/// 名字
/// 说明：类和子类可访问
/// </summary>
protected string name;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="name"></param>
public Animal(string name)
{
this.name=name;
}
/// <summary>
/// 名字(虚属性)
/// </summary>
public virtual string MyName
{
get { return this.name; }
}
/// <summary>
/// 吃（虚方法）
/// </summary>
public virtual void Eat()
{
Console.WriteLine("我会吃!");
}
/// <summary>
/// 叫（虚方法）
/// </summary>
public virtual void Shout()
{
Console.WriteLine("我会叫！");
}
}
/// <summary>
/// 狗（子类）
/// </summary>
class Dog:Animal
{
string myName;
public Dog(string name): base(name)
{
myName = name;
}
/// <summary>
/// 名字(重写父类属性)
/// </summary>
public override string MyName
{
get { return "我是：狗狗，我叫："+this.name; }
}
/// <summary>
/// 吃(重写父类虚方法)
/// </summary>
new public void Eat()
{
Console.WriteLine("我喜欢吃肉!");
}
/// <summary>
/// 叫（重写父类方法）
/// </summary>
public new void Shout()
{
Console.WriteLine("汪!汪!汪！");
}
}
可以看出，当派生类Dog的Eat()方法使用new修饰时，Dog的对象转换为Animal对象后，调用的是Animal类中的Eat()方法。其实可以理解为，使用new关键字后，使得Dog中的Eat()方法和Animal中的Eat()方法成为毫不相关的两个方法，只是它们的名字碰巧相同而已。所以， Animal类中的Eat()方法不管用还是不用virtual修饰，也不管访问权限如何，或者是没有，都不会对Dog的Eat()方法产生什么影响（只是因为使用了new关键字，如果Dog类没用从Animal类继承Eat()方法，编译器会输出警告）。
我想这是设计者有意这么设计的，因为有时候我们就是要达到这种效果。严格的说，不能说通过使用new来实现多态，只能说在某些特定的时候碰巧实现了多态的效果。
原文地址：https://www.cnblogs.com/TheMiao/p/9271401.html