抽象类

  abstract class MyBaseClass
    {
       public void print()
       {
           Console.WriteLine("抽象类中的public方法");

       }
       abstract public void PrintAcstract();
       virtual public void PrintVirtual() {
           Console.WriteLine("这是基类中的虚方法。");
       }

    }
    class MyClass : MyBaseClass
    {
        public sealed override void PrintAcstract()
        {

            Console.WriteLine("派生类中实现抽象类的抽象方法。");
        }
        public override void PrintVirtual()
        {
            //base.PrintVirtual();
            Console.WriteLine("这里重写了基类中的虚方法。");
        }
        public void Printddd() {
            base.PrintVirtual();
        }
       
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass ss = new MyClass();
            ss.print();
            ss.PrintAcstract();
            ss.PrintVirtual();
            ss.Printddd();


            var dd = (MyBaseClass)ss;         
            dd.PrintVirtual();

            Console.WriteLine();
            Console.ReadKey();

        }
    }

今天在学习抽象方法，抽象类，虚方法的时候突然想到前面看过的构造函数，想起来前面访问基类的方法有一种是先实例化一个派生类的对象，然后

对派生类的对象进行强制转换就可以访问单基类的成员。

 B ss = new B();//派生类实例

 var dd = (A)ss;//转化基类实例对象


但是对于抽象类（上面的代码）    ，我竟然有这样的想法，虽然知道不合理但是还是尝试了一下，

            var dd = (MyBaseClass)ss;         
            dd.PrintVirtual();
这段代码就是转换的，但是我不是很明白怎么理解这段代码：

因为他没有什么报错，运行结果是派生类重写的结果，打上断点如图：

发现并没有转换成功，说明对于抽象类这个不能实例化的东西来说，并不能将基类的实例转成功。所以仍然调用的是派生类的方法。
这里理解的深度还不够，先做个笔记，希望有更好解释的筒子们给我留言。