重写（覆盖）（override）和重载（overload）的区别（面试题）

1).重写（override）

override是重写（覆盖）了一个方法，以实现不同的功能，一般的用于子类在继承父类时，重写（重新实现）父类的方法，实现不同的需求。

重写（覆盖）的规则：

1.重写的方法必须是virtual，abstract或者是override（virtual修饰符不能与static，abstract，private或override修饰符一起使用，静态属性上使用virtual修饰符会报错）。

2.重写方法的参数列表必须完全与被重写的方法相同，否则不能称为重写而是重载。

3.重写的方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。

4.重写的方法的返回值必须和被重写的方法返回值一致。

5.重写的方法所抛出的异常必须和被重写的方法所抛出的异常一致，或是其子类（eg:父类的一个方法申明了一个检查异常IOException，在重写这个方法就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常）。

6.被重写的方法不能为private，否则在其子类中只是定义了一个新的方法，并没有对其重写。

7.静态方法不能被重写为非静态方法（会编译出错）。

8.子类不能重写父类中的final修饰的方法。

代码实现：

  /// <summary>
         /// 定能基类动物类
         /// </summary>
         /// <returns></returns>
          public class Animal
          {
           public virtual void Eatting()
             {
                  Console.WriteLine("用嘴吃饭！");
             }
          }
  
         #region 重写（覆盖原则）
 
          public class Pople : Animal
        {
             public override void Eatting() //基类必须是virtual方法
             {
                 Console.WriteLine("人用筷子吃饭！");
              }
          }
  
         public class Monkey : Animal
         {
              public new void Eatting()
              {
                  Console.WriteLine("猴子直接用手吃饭！");
              }
          }
 
  
        #endregion
 
          /// <summary>
          /// 方法重载和冲写的区别
          /// </summary>
   /// <param name="args"></param>
          public static void Main(string[] args)
          {
           var pople = new Pople();
              (pople as Animal).Eatting(); //打印【人用筷子吃饭！】
             pople.Eatting();//打印【人用筷子吃饭！】
 
              var monKey = new Monkey();
            (monKey as Animal).Eatting();//打印【用嘴吃饭！】
             monKey.Eatting();//打印【猴子直接用手吃饭！】
 
             Console.ReadKey();
          }

2).重载（overload）

overload是重载，一般是用于在一个类实现若干重载的方法，这些方法的名称相同参数不同。

重载的规则：

1.在使用重载时只能通过相同的方法名，不同的参数形式类实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）。

2.不能通过访问权限，返回类型，抛出的异常进行重载。

3.方法的异步类型和数目不会对重载造成影响。

 using System;
 using System.Threading.Tasks;
  
 namespace OverReadOverLoadDifference
 {
     class Program
     {
       #region 方法重载
 
        /// <summary>
         /// 定义计算类
        /// </summary>
         public class Calculation
         {
              public int sunMation(int a)
              {
                  return a;
             }
 
             public int sunMation(int a, int b)
              {
                  return a + b;
            }
          }
  
          #endregion
 
         /// <summary>
          /// 方法重载
          /// </summary>
          /// <param name="args"></param>
         public static void Main(string[] args)
         {
             var calculation = new Calculation();
            Console.WriteLine(calculation.sunMation(1));
            Console.WriteLine(calculation.sunMation(2, 3)); 
             #endregion
  
             Console.ReadKey();
          }
      }
  }