public abstract class C
    {
        public string strAbs;
        protected C()
        {
            Console.WriteLine("abstract class C");
        }

        // 子类显示调用才会执行有参构造函数
        protected C(string str)
        {
            strAbs = str;
        }

        public void Method1()
        {
            Console.WriteLine("abstract class:method");
        }

        //public void Method2();错误的写法 抽象类中的方法必须有方法体
        public void Method2()
        {
            //有方法体，可以没有具体实现
        }
        //抽象类中可以有抽象方法，但是抽象方法不能有方法体，也就是没有实现部分
        public abstract void Mehod3();

       // public virtual void Method4();错误的写法：抽象类中的虚方法必须有方法体
        public virtual void Method4()
        {
            Console.WriteLine("abstract class virtual method");
        }
    }

    public abstract class E:C
    {
        /// <summary>
        /// 子类实例化时会先走父类无参构造函数
        /// </summary>
        protected E()
        {
            Console.WriteLine("abstract class E");
        }

        /// <summary>
        /// 子类显示调用才会执行有参构造函数
        /// </summary>
        /// <param name="str"></param>
        protected E(string str)
        {
            this.strAbs = str;
        }

        //子类继承抽象类，必须重写抽象类中的抽象方法
        public override void Mehod3()
        {

        }

        //子类继承抽象类，对于抽象类的虚方法，要么用重写(override)要么用new覆盖，二者只能选其一
        public override void Method4()
        {
            Console.WriteLine("E:C override method");
        }
        //public new void Method4()
        //{
        //    Console.WriteLine("E:C new method");
        //}
    }

    public class F:E
    {
        //显示调用父类有参构造函数
        public F(string str):base(str)
        {
            strAbs = str;
        }
    }