C#方法重载（overload）方法重写（override）隐藏（new）

一、重载:同一个作用域内发生（比如一个类里面），定义一系列同名方法，但是方法的参数列表不同。这样才能通过传递不同的参数来决定到底调用哪一个。

        值得注意的是,方法重载只有通过参数不同来判断调用哪个方法，而不能通过返回值。至于原因，可以这样理解，你调用一个方法，如果有多个方法同名，系统必须要知道到底你要调用哪一个，参数可以帮助系统在方法入口处得到答案，他根据你给的参数就知道该使用哪个方法。如果只有返回值的不同，很多情况系统是不可能得到有效的判断条件的，比如：double method();int method();如果你这样调用:method()。系统当然不知道该调用哪个。

示例：

 //返回值相同，参数不同

   

  1.  class  BillPayment
  2.     {
  3.         void PayBill(int TelephoneNumber)
  4.         {
  5.             //此方法用于支付固定电话费
  6.         }
  7.         void PayBill(long CustomerNumber)
  8.         {
  9.             //此方法用于支付电费
  10.         }
  11.         void PayBill(long CustomerNumber,double amount)
  12.         {
  13.             //次方法用于支付移动电话费
  14.         }
  15.     }
  16. }

 

//返回值相同，参数个数不同

  1. class Add
  2. {
  3.     int addtion(int num1,int num2)
  4.     {
  5.         return num1+num2;
  6.     }
  7.     int addtion(int num1,int num2,int num3)
  8.     {
  9.         returnnum1+num2+num3;
  10.     }
  11. }


 

//参数不同，返回值不同

  1. int Method(int[] numbers)
  2. {
  3. }
  4. double Method(double[] numbers)
  5. {
  6. }


 

         注：泛型出现后，相同参数，相同返回值的方法也能构成重载，这里不介绍。

 

         

二、重写：继承时发生，在子类中重新定义父类中的方法，子类中的方法和父类的方法是一样的，即方法名，参数，返回值都相同。

          例如:基类方法声明为virtual(虚方法)，派生类中使用override申明此方法的重写.

          

          重写override一般用于接口实现和继承类的方法改写，要注意：

          1、覆盖的方法的标志必须要和被覆盖的方法的名字和参数完全匹配，才能达到覆盖的效果；

          2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

          3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

          4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

        示例：

  1. namespace 方法重写
  2. {
  3.     class Program
  4.     {
  5.  
  6.         static voidMain(string[] args)
  7.         {
  8.             BaseClass CO =new ClassOverride();
  9.            CO.SetName("Override");
  10.         }
  11. //基类
  12.         public classBaseClass
  13.         {
  14.             public virtualvoid SetName(string name)
  15.             {
  16.                Console.WriteLine("基类：我的名字是" + name);
  17.             }
  18.         }
  19.  
  20. //派生类
  21.         public classClassOverride : BaseClass
  22.         {
  23.             publicoverride void SetName(string name)
  24.             {
  25.                Console.WriteLine("Override：我的名字是" + name);
  26.             }
  27.         }
  28.  
  29.     }
  30. }


      在方法重写中，我们介绍了虚方法，那么虚方法和抽象方法有什么区别呢？

 

1．虚方法有一个实现部分可以被子类继承，从而使子类获得和基类相同的方法，另外也为派生类提供了覆盖该方法的选项。相反，抽象方法没有提供实现部分，是一种强制派生类覆盖的方法（否则派生类不能成具体类）

 

2.（abstract）抽象方法只能在抽象类中声明,（virtual）虚方法不是。

 

3.（abstract）抽象方法必须在派生类中重写而（virtual）虚方法不必。

 

4.（abstract）抽象方法不能声明方法实体，虚方法可以。

 

 

          个人感觉，方法重载和方法重写都有点像多态，同一个方法的多种形态：执行“相同”的方法，却通过它们自己的实现代码来实现,即同一种方法，不同的对象会产生不同的结果。

 

三、隐藏（方法）：基类方法不做申明（默认为非虚方法），在派生类中使用new声明此方法的隐藏。隐藏时，访问父类则调用父类的方法，访问子类则调用子类的方法。

示例：  

  1. namespace 隐藏
  2. {
  3.     class Program
  4.     {
  5.  
  6.         static voidMain(string[] args)
  7.         {
  8.             ClassNew CN =new ClassNew();
  9.            CN.SetName("new");
  10.  
  11.             BaseClass BC =CN;
  12.            BC.SetName("基类");
  13.         }
  14.                  //基类
  15.         public classBaseClass
  16.         {
  17.             public voidSetName(string name)
  18.             {
  19.                Console.WriteLine("基类：我的名字是" + name);
  20.             }
  21.         }
  22. //派生类
  23.         public classClassNew : BaseClass
  24.         {
  25.                           //这里如果不使用new，将生成警告！
  26.             new publicvoid SetName(string name)
  27.             {
  28.                Console.WriteLine("new：我的名字是" + name);
  29.             }
  30.         }
  31.     }
  32. }


运行结果：new：我的名字是new

                   基类：我的名字是基类

 

如果上述扔不好理解，我们再举一个隐藏静态变量的例子

 

  1. namespace 隐藏继承成员
  2. {
  3.     class Program
  4.     {
  5.         public classBaseClass
  6.         {
  7.            public static int A = 123;
  8.         }
  9.  
  10.         public classClassNew : BaseClass
  11.         {
  12.            new public static int A = 456;
  13.  
  14.             static voidMain(string[] args)
  15.             {
  16.                Console.WriteLine(A);
  17.             }
  18.  
  19.         }
  20.     }
  21. }


       运行结果：456

 

 

        注：不仅有方法隐藏，还有其他的，通过继承隐藏名称一般采用下列形式之一： 

 

1.引入类或结构中的常数、指定、属性或类型隐藏具有相同名称的所有基类成员。

 

2.引入类或结构中的方法隐藏基类中具有相同名称的属性、字段和类型。同时也隐藏具有相同签名的所有基类方法。

 

3.引入类或结构中的索引器将隐藏具有相同名称的所有基类索引器。

 

4.在同一成员上同时使用 new 和 override 是错误的。

 

         另外，在不隐藏继承成员的声明中使用 new 修饰符将生成警告。在隐藏继承成员的生命中不使用new修饰符也将产生警告

posted @ 2022-04-28 16:17  mkmkbj  阅读(842)  评论(0)  编辑  收藏  举报