using System;
using System.Collections.Generic;
using System.Text;
namespace 类的继承问题01
{
    class Program
    {
        static void Main(string[] args)
        {
            //A Aa = new A();
            //Aa.BaseMethod();  //调用自身的方法，即调用A类中的BaseMethod()方法
            B Ba = new B();
            A Aa = Ba;         //隐式转换，或者是上强制类型转换
            Aa.BaseMethod();   //多态，调用B类中重写的BaseMethod()方法
            //B Ba = new B();
            //Ba.BaseMethod();   //调用自身的方法，即调用B类中的BaseMethed()方法
            //B Ba = new B();
            //A Aa = Ba;
            //Ba = (B)Aa;        //强制类型转换，Aa必须满足：Aa的实际类型必须是B或者是继承自B的类的类型
            //Ba.BaseMethod();   //调用自身的方法，即调用B类中的BaseMethed()方法
            //C Ca = new C();
            //B Ba = Ca;
            //Ca = (C)Ba;        //强制类型转换，Ba必须满足：Ba的实际类型必须是C或者是继承自C的类的类型
            //Ca.BaseMethod();   //调用自身的方法，即调用C类中的BaseMethed()方法
            //C Ca = new C();
            //A Aa = Ca;
            //Ca = (C)Aa;        //强制类型转换，Aa必须满足：Aa的实际类型必须是C或者是继承自C的类的类型
            //Ca.BaseMethod();   //调用自身的方法，即调用C类中的BaseMethed()方法
           // D Da = new D();
           // A Aa = Da;
           // C Ca;
           ////在整个这一小代码段里可以换成 C Ca = new C();
           // Ca = (C)Aa;              //强制类型转换，Aa必须满足：Aa的实际类型必须是C或者是继承自C的类的类型
           // Ca.BaseMethod();        // ?多态 最后调用的是D类中的BaseMethed()方法，原因是Aa的实际类型是D
            //C Ca = new C();
            //B Ba = new B();
            //A Aa = Ba;
            //Ca = (C)Aa;   //这里会发生异常，原因是Aa的实际类型是B，而现在是想把Aa强制转换为C，而C是从B 派生的
            //Ca.BaseMethod();//所以会发生异常
            //C Ca = new C();
            //B Ba = new B(); //在整个这一小代码段里可以换成B Ba;
            //A Aa = Ca; 
            //Ba = (B)Aa;
            //Ba.BaseMethod();//?多态 最后调用的是C类中的BaseMethed()方法，原因是Aa的实际类型是C
            //C Ca = new C();
            //B Ba = Ca;          //隐式转换，或者是上强制类型转换
            //Ba.BaseMethod();    //多态调用C类中重写的BaseMethod()方法
            //C Ca = new C();
            //A Aa = Ca;          //隐式转换，或者是上强制类型转换
            //Aa.BaseMethod();    //多态调用C类中重写的BaseMethod()方法
            //C Ca = new C();
            //Ca.BaseMethod();      //调用自身的方法，即调用C类中的BaseMethed()方法
            Console.ReadKey();
           
         
        }
    }
    class A
    {
        public virtual void BaseMethod()
        {
            Console.WriteLine("ABaseMethod");
        }
    }class B:A
    {
               /* B类中被重写的BaseMethod()方法在B类的各级后代类里仍将是一个virtual方法，就是说你可以在B类的后代类中再次重写这个方法，例如C类中的BaseMethod()方法 */
        public override void BaseMethod()  
        {                                               
             Console.WriteLine("BBaseMethod");
        }
    }
    class C:B
    {
        public override void BaseMethod()
        {
            Console.WriteLine("CBaseMethod");
        }
    }
    class D : C
    {
        public new  void BaseMethod()   //在这里可以通过new隐藏基类C中的public override void BaseMethod(){.....}方法
        {
            Console.WriteLine("DBaseMethod");
        }
    }
}
// 保留子new可以和vietual一起用，但不能和override一起用