第二节:覆写(new)、重写(override)、和重载(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父类,里面有三个方法。

 1   public abstract class parentClass
 2     {
 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 : parentClass
 2     {
 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 parentClass
 2     {
 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 : parentClass
 2     {
 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的两个方法就是重载

 

!

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