第二节：重写（new）、覆写（overwrite）、和重载（overload）

一. 覆盖/写

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父类，里面有三个方法。

   public abstract class parentClass
     {
         //下面两个普通方法实现自身的重载
         public void CommonMethord1()
         {
             Console.WriteLine("parentClass CommonMethord1");
         }
         public void CommonMethord1(string msg)
         {
             Console.WriteLine("parentClass CommonMethord1");
         }
         public void CommonMethord2()
         {
             Console.WriteLine("parentClass CommonMethord2");
         }
     }

4. 声明一个childClass类，里面重写了两个方法。

  public class childClass : parentClass
     {
         /// <summary>
         /// 单独声明子类实例的时候,将替换父类中的方法
         /// </summary>
         public void CommonMethord1()
         {
             Console.WriteLine("childClass CommonMethord1");
         }
         /// <summary>
         /// new 关键字去除上述警告，单独声明子类实例的时候,将替换父类中的方法
         /// </summary>
         /// <param name="msg"></param>
         public new void CommonMethord1(string msg)
         {
             Console.WriteLine("childClass CommonMethord1");
         }
     }

5. 调用

  {
                 parentClass p1 = new childClass();
                 childClass p2 = new childClass();
                 Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");
                 p2.CommonMethord1();          //结果：子类方法    (非显式隐藏，但也隐藏了，会报警告)
                 p2.CommonMethord1("ddd");     //结果：子类方法    (含有new关键字，显式的隐藏了父类中的方法，没有警告)
                 p2.CommonMethord2();          //结果：父类方法

                 Console.WriteLine("-----------------------------2.普通方法重写，调用的都是父类方法--------------------------------------");
                 p1.CommonMethord1();         //结果：父类方法
                 p1.CommonMethord1("ddd");    //结果：父类方法
                 p1.CommonMethord2();         //结果：父类方法
 }

二. 重写

1. 关键字：override

2. 含义：在子类中，继承的父类中的抽象方法(abstract)和虚方法(virtual),子类可以对其进行重写,其中父类中的抽象方法,子类中必须被重写。

　抽象方法：没有方法体，子类必须重写。

　虚方法：必须有方法体，子类可以对其进行重写，也可以不进行重写。

3. 新建一个名叫parentClass的抽象类，里面有一个抽象方法和两个虚方法。

    public abstract class parentClass
     {
         //下面为抽象方法
         public abstract void abstractMethord();
         //下面两个方法为虚方法
         public virtual void virtualMethord1()
         {
             Console.WriteLine("parentClass virtualMethord1");
         }
         public virtual void virtualMethord2()
         {
             Console.WriteLine("parentClass virtualMethord2");
         }
     }

4. 新建一个childClass子类，继承parentClass类，并且对virtualMethord2虚方法进行重写

   public class childClass : parentClass
     {

         public override void abstractMethord()
         {
             Console.WriteLine("childClass abstractMethord");
         }
         //加上sealed关键字，子类将不能对其继续进行重写
         public sealed override void virtualMethord2()
         {
             Console.WriteLine("childClass virtualMethord2");
         }
     }

5. 调用 （总结：子类有的方法，都是调用子类方法）

  　　　　　　　　 parentClass p1 = new childClass();
                 childClass p2 = new childClass();
                 Console.WriteLine("-----------------------------1.子类的直接调用--------------------------------------");
                 p2.abstractMethord();           //结果：子类方法
                 p2.virtualMethord1();           //结果：父类方法
                 p2.virtualMethord2();           //结果：子类方法
                 Console.WriteLine("-----------------------------2.抽象类(符合里氏替换原则)的形式调用--------------------------------------");
                 p1.abstractMethord();           //结果：子类方法
                 p1.virtualMethord1();           //结果：父类方法
                 p1.virtualMethord2();           //结果：子类方法

三. 重载（overload）

1. 关键字：无关键字

2. 含义：在同一个类中，同一个名称的方法参数的个数不同、参数类型不同、参数个数和参数类型都不同

eg: parentClass中的CommonMethord1的两个方法就是重载

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 本人才疏学浅，用郭德纲的话说“我是一个小学生”，如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。