一. 重写
1. 关键字：new
2. 含义：子类继承父类中的普通方法，如果在子类中重写了一个和父类中完全相同的方法，子类中会报警告(问是否显式的隐藏父类的中的方法)，如果在子类中的方法前加上new关键字，则警告消失。
注意：
* 虽然可以不使用 new 修饰符来隐藏成员，但将收到编译器警告。 如果使用 new 来显式隐藏成员，将禁止此警告。
* 这里需要特别注意，隐藏父类方法是指声明的完全是子类实例, eg child类继承parent类, 并在child类中重新声明了一个和parent中相同的方法show。
那么分两种情况：
* a. child c=new child(); c.show()进行调用，无论child类中的show方法前加没加new关键字，调用的都是child类中的方法,只是加上new关键字后，不出警告。
* b. parent p=new child(); p.show()进行调用，无论child类中的show方法前加没加new关键字，调用的都是parent类中的方法，因为这是不同方法，不涉及override，不满足上述声明的new关键字替换父类中的方法的描述。
3. 声明一个parentClass父类，里面有三个方法。
1 public abstract class parentClass2 {3 //下面两个普通方法实现自身的重载4 public void CommonMethord1()5 {6 Console.WriteLine("parentClass CommonMethord1");7 }8 public void CommonMethord1(string msg)9 {
10 Console.WriteLine("parentClass CommonMethord1");
11 }
12 public void CommonMethord2()
13 {
14 Console.WriteLine("parentClass CommonMethord2");
15 }
16 }4. 声明一个childClass类，里面重写了两个方法。
1 public class childClass : parentClass2 {3 /// <summary>4 /// 单独声明子类实例的时候,将替换父类中的方法5 /// </summary>6 public void CommonMethord1()7 {8 Console.WriteLine("childClass CommonMethord1");9 }
10 /// <summary>
11 /// new 关键字去除上述警告，单独声明子类实例的时候,将替换父类中的方法
12 /// </summary>
13 /// <param name="msg"></param>
14 public new void CommonMethord1(string msg)
15 {
16 Console.WriteLine("childClass CommonMethord1");
17 }
18 }5. 调用
1 {2 parentClass p1 = new childClass();3 childClass p2 = new childClass();4 Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");5 p2.CommonMethord1(); //结果：子类方法 (非显式隐藏，但也隐藏了，会报警告)6 p2.CommonMethord1("ddd"); //结果：子类方法 (含有new关键字，显式的隐藏了父类中的方法，没有警告)7 p2.CommonMethord2(); //结果：父类方法8 9 Console.WriteLine("-----------------------------2.普通方法重写，调用的都是父类方法--------------------------------------");
10 p1.CommonMethord1(); //结果：父类方法
11 p1.CommonMethord1("ddd"); //结果：父类方法
12 p1.CommonMethord2(); //结果：父类方法
13 }二. 覆写
1. 关键字：override
2. 含义：在子类中，继承的父类中的抽象方法(abstract)和虚方法(virtual),子类可以对其进行覆写,其中父类中的抽象方法,子类中必须被覆写。
抽象方法：没有方法体，子类必须覆写。
虚方法：必须有方法体，子类可以对其进行覆写，也可以不进行覆写。
3. 新建一个名叫parentClass的抽象类，里面有一个抽象方法和两个虚方法。
1 public abstract class parentClass2 {3 //下面为抽象方法4 public abstract void abstractMethord();5 //下面两个方法为虚方法6 public virtual void virtualMethord1()7 {8 Console.WriteLine("parentClass virtualMethord1");9 }
10 public virtual void virtualMethord2()
11 {
12 Console.WriteLine("parentClass virtualMethord2");
13 }
14 }4. 新建一个childClass子类，继承parentClass类，并且对virtualMethord2虚方法进行覆写
1 public class childClass : parentClass2 {3 4 public override void abstractMethord()5 {6 Console.WriteLine("childClass abstractMethord");7 }8 //加上sealed关键字，子类将不能对其继续进行覆写9 public sealed override void virtualMethord2()
10 {
11 Console.WriteLine("childClass virtualMethord2");
12 }
13 }5. 调用
1 parentClass p1 = new childClass();2 childClass p2 = new childClass();3 Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");4 p2.abstractMethord(); //结果：子类方法5 p2.virtualMethord1(); //结果：父类方法6 p2.virtualMethord2(); //结果：子类方法7 Console.WriteLine("-----------------------------2.抽象类(符合里氏替换原则)的形式调用--------------------------------------");8 p1.abstractMethord(); //结果：子类方法9 p1.virtualMethord1(); //结果：父类方法
10 p1.virtualMethord2(); //结果：子类方法三. 重载（overload）
1. 关键字：无关键字
2. 含义：在同一个类中，同一个名称的方法参数的个数不同、参数类型不同、参数个数和参数类型都不同
eg: parentClass中的CommonMethord1的两个方法就是重载
