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()
        */