C# onverride、abstract、vitrtual、new、sealed

abstract：

• 抽象方法是隐式的虚方法
• 在抽象方法声明中，不能使用static或者virtual修饰符

override：

• override关键字提供派生类对基类方法的新的实现，重写的基类方法必须和基类的方法有着相同的签名（函数名、返回值、参数列表相同）。
• override关键字不可以重写基类非virtual修饰的方法和static修饰的静态方法。派生类的override方法重写的基类方法必须是virtual、abstract或者override的。
• 派生类的override方法和基类的virtual方法必须有相同的访问权限
• 不能用修饰符new、static、virtual或者abstract修饰override方法。

new：

• 作为修饰符覆盖父类的方法(不必是虚方法)，当使用子类的类型来调用的时候，它会运行子类的函数，而如果类型是基类的话，被隐藏的基类函数会被调用，而子类中函数使用override的时候，则当使用子类的类型来调用的是，它会运行子类的函数，类型是基类的时候，仍会调用子类函数。

　class Car
  {
      public virtual void DescribeCar()
      {
          System.Console.WriteLine("Four wheels and an engine.");
      }
  }
  class ConvertibleCar : Car
  {
      public new void DescribeCar()
      {
          System.Console.WriteLine("A roof that opens up.");
      }
  }
  class Minivan : Car
  {
      public override void DescribeCar()
      {
          System.Console.WriteLine("Carries seven people.");
      }
  }
  public class Program
  {
      public static void Main()
      {
          Car car1 = new Car();
          car1.DescribeCar();
          System.Console.WriteLine("----------");        //Four wheels and an engine.

　　　　　　ConvertibleCar car2x = new ConvertibleCar();
          car2x.DescribeCar();
          System.Console.WriteLine("----------");        //A roof that opens up.

          Car car2 = new ConvertibleCar();
          car2.DescribeCar();
          System.Console.WriteLine("----------");        //Four wheels and an engine.

　　　　　　Minivan car3x = new Minivan();
          car3x.DescribeCar();
          System.Console.WriteLine("----------");        //Carries seven people.

　　　　　　Car car3 = new Minivan(); 
　　　　　　car3.DescribeCar(); 
　　　　　　System.Console.WriteLine("----------");       //Carries seven people.

　　　　　　System.Console.ReadKey(); } } 

virtual： 

　　修饰方法表示允许在派生类中重写这些对象，默认情况下，方法是非虚拟的，不可以重写非虚方法，virtual关键字不可以与static、abstract、private、override一起使用。

　　virtual关键字又是和override紧密不可分的，如果要实现virtual方法就必须要使用override或new关键字（上文已经指出new和override产生的机理不同）。

sealed：

　　当对一个类应用sealed修饰符时，此修饰符会阻止其他类从该类继承。

　　sealed 方法必须与override连用，也就是说实现sealed方法的类的父类必须实现了此方法。

　　密封方法重写基类中的方法，但其本身不能在任何派生类中进一步重写

　　class X  

    {
        protected virtual void F() { Console.WriteLine("X.F"); }
        protected virtual void F2() { Console.WriteLine("X.F2"); }
    }
    class Y : X
    {
        sealed protected override void F() { Console.WriteLine("Y.F"); }
        protected override void F2() { Console.WriteLine("X.F3"); }
    }
    class Z : Y
    {
        // Attempting to override F causes compiler error CS0239.
        // protected override void F() { Console.WriteLine("C.F"); }//sealed修饰的方法是不允许继承的  

        // Overriding F2 is allowed.
        protected override void F2() { Console.WriteLine("Z.F2"); }
    }  

整体例子：

namespace testVirtualF
{
    interface BaseInterface
    {
        void doWork();
    }
    public abstract class Base:BaseInterface
    {
        public virtual void work()
        {
            Console.WriteLine("基类---现在是上班时间");
        }
        public virtual void outWork()
        {
            Console.WriteLine("基类---现在是下班时间");
        }  

        public abstract void play();//声明抽象方法,只能在抽象方法中
        public abstract void doWork();//实现接口的抽象类，可以将接口方法映射到抽象方法中
    }  

    public class Employer:Base
    {
        public  new void work()
        {
            Console.WriteLine("子类(new)---现在是上班时间");
        }
        public override void outWork()
        {
            Console.WriteLine("子类(override)---现在是下班时间");
        }
        public override void play()
        {
            Console.WriteLine("子类(override)---父类抽象方法");
        }
        public override void doWork()
        {
            Console.WriteLine("父类抽象方法--doWork");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            /*Employer emp = new Employer();
            emp.work();
            emp.outWork();
            emp.play();*/
            /*输出结果
             * 子类(new)---现在是上班时间
             * 子类(override)---现在是下班时间
             */  

            /*Employer emp = new Employer();
            Base b = (Base)emp;
            //b.ID = "123";
            b.work();
            b.outWork();
            b.play();*/
            /*执行结果
             * 基类---现在是上班时间
             * 子类(new)---现在是上班时间
             * 子类(override)---现在是下班时间
             */  

            Base b = new Employer();
            b.work();
            b.outWork();
            b.play();
            /*执行结果
             * 基类---现在是上班时间
             * 子类(new)---现在是上班时间
             * 子类(override)---现在是下班时间
             */
        }
    }
}