C# new,Virtual,abstract,sealed,Override的簡單理解

    new

    new 关键字可以显式隐藏从基类继承的成员。隐藏继承的成员意味着该成员的派生版本将替换基类版本。也就说在使用派生类的方法是调用的方法是New关键字新定义出来的方法，而不是基类的方法。
   在不使用 new 修饰符的情况下隐藏成员是允许的，但会生成警告。使用 new 显式隐藏成员会取消此警告，并记录代之以派生版本这一事实。

    Virtual

    Virtual 关键字允许在派生类中重写这些对象，默认情况下，方法是非虚拟的，不可以重写非虚方法，virtual关键字不可以与static、abstract、private、override一起使用。
    Virtual关键字又是和override紧密不可分的，如果要实现Virtual方法就必须要使用override或new关键字（new和override产生的机理不同）。

    abstract

        在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。抽象类不能实例化。
        抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。

        sealed

        密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。密封类不能被继承。
        当应用于方法或属性时，sealed修饰符必须始终与override一起使用。

    Override

    Override关键字主要是提供派生类对基类方法的新实现，重写的基类方法必须和Override的方法具有相同的签名

        下邊用例字作簡單說明，例字比較繁瑣，僅作為參考！
        例子的主要想法過程為：

               基類A
                B：A
abstract C：B
sealed   D：C

       類中包含的方法想法過程為：
                     方法  A
                     new   A
                  virtual   A
               abstract  A
               override  A
  sealed override   A

 class Program
    {
        /// <summary>
        /// 定義一個基類"MyBaseClass"
        /// </summary>
        public class MyBaseClass
        {
            /// <summary>
            /// 定義一個方法
            /// </summary>
            public void DoA()
            {
                Console.WriteLine("MyBaseClass . Base DoA()");
            }
        }

        /// <summary>
        /// 定義個繼存類MyInheritClass繼承MyBaseClass類
        /// </summary>
        public class MyInheritClass : MyBaseClass
        {

            /// <summary>
            /// 此地方表示隱藏基類MyBaseClass中的DoA方法，並重寫方法
            /// </summary>
            new public void DoA()
            {
                Console.WriteLine("MyBaseClass . Inherit Base DoA()");

                //運行基類MyBaseClass的DoA方法
                base.DoA();
            }
           
            /// <summary>
            /// 定義一個虛方法
            /// </summary>
            public virtual  void DoB()
            {
                Console.WriteLine("MyBaseClass . Inherit Base DoB()");
            }
         }

        /// <summary>
         /// 定義抽象類MyAbstractClass繼承類MyInheritClass
        /// </summary>
        ///  abstract
        public abstract class MyAbstractClass : MyInheritClass
        {
            /// <summary>
            /// 隱MyInheritClass類的方法，重新定義抽象方法
            /// </summary>
            new  public abstract void DoA();
            /// <summary>
            /// 重寫基類MyInheritClass方法，此方法為新的方法
            /// </summary>
            public override void DoB()
            {
                Console.WriteLine("MyBaseClass . abstract  override DoB() ");

                //此時將調用MyInheritClass類中的方法
                base.DoA();
            }
        }

        /// <summary>
        /// 定議密封類MySealedClass繼承抽像類MyAbstractClass
        /// </summary>
        public sealed class MySealedClass : MyAbstractClass
        {
            /// <summary>
            /// 重寫基類MyAbstractClass的抽象方法
            /// </summary>
            public override void DoA()
            {
                Console.WriteLine("MyBaseClass . sealed  DoA() ");               
            }
           
            /// <summary>
            /// 密封重寫MyAbstractClass方法
            /// </summary>
            public sealed override void DoB()
            {
                Console.WriteLine("MyBaseClass . sealed  override DoB() "); 
            }

            public void CallBase()
            {
                //此時不是調用基類MyBaseClass(抽象類)的方法是調用MyAbstractClass類的方法
                base.DoB();
                //此處報錯。因為繼承抽象的方法無法調用原始方法
                //base.DoA();
            }
        }

        static void Main(string[] args)
        {
            //實例化基類並調用基類方法
            MyBaseClass BaseClasee = new MyBaseClass();
            BaseClasee.DoA();

            //實例化繼承類，並調用繼承類方法
            MyInheritClass InheritCalss = new MyInheritClass();
            InheritCalss.DoA();
            InheritCalss.DoB();

            //實例化密封類，並調用方法
            MySealedClass SealedClass = new MySealedClass();
            SealedClass.DoA();
            SealedClass.DoB();
            SealedClass.CallBase();
            Console.ReadKey();
        }
    }

        /*
         * 輸出結果
         * MyBaseClass . Base DoA()
         * 
         * MyBaseClass . Inherit Base DoA()
         * MyBaseClass . Base DoA()
         * MyBaseClass . Inherit Base DoB()         
         *  
         * MyBaseClass . sealed  DoA()  
         * MyBaseClass . sealed  override DoB() 
         * 
         *MyBaseClass . abstract  override DoB()
         *MyBaseClass . Inherit Base DoA()
         * MyBaseClass . Base DoA()
        */