一个经典的问题（构造函数调用+抽象类+间接继承抽象类）

经典案例
案例1：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    abstract class Test1
    {
        public int Num1 { get; private set; }
        public int Num2 { get; private set; }
        public Test1(int num1,int num2)
        {
            Num1=num1;
            Num2=num2;
        }
        public abstract int Sum();
    }

    class Test2:Test1
    {
        private int num3;
        public Test2(int num1, int num2, int num3):base(num1,num2)
        {
            Num3 = Sum();//问题：初始化Num3的时候调用的是Test3的方法而不是 Test2的？为什么
        }
        public int Num3
        {
            get { return num3; }
            set { num3 = value; }
        }
        public override int Sum()
        {
            return ++Num3;
        }
    }

    class Test3:Test2
    {
       private int num4;
        public Test3(int num1, int num2, int num3,int num4):base(num1,num2,num3)
        {
            Num4 = num4;
        }
        public int Num4
        {
            get { return num4; }
            set { num4 = value; }
        }

        //public override int Sum()//因为是第三个类的对象，所以说对于方法的调用都是在 第三个类里，如果第三个类里的方法没有重写，那么会继承第2个的方法，调用第二个类的方法
        //{
        //    return Num4+base.Sum();
        //}

    }

    class P
    {
        static void Main()
        {
            Test3 onetest3 = new Test3(1,2,3,4);
        }
        
    }
}

问题：

间接继承抽象类，重写方法是 父类的方法还是抽象类的方法？

答：间接继承抽象类的类 重写方法是父类的方法，“近水楼台先得月”！

注：
间接继承抽象类，重写方法是 父类的方法的，
直接继承抽象类，对于抽象类的方法那叫实现


答案：
如果没有注释Test3的Sum方法：
1.对于直接继承抽象类，必须实现  抽象类的抽象方法，如Test2
2.因为对象是在Test3建立的，而且Test3重写了父类Test2的方法，所以必须用本类的Sum方法。

如果把Test3的Sum方法注释：
1.对于直接继承抽象类，必须实现  抽象类的抽象方法，如Test2
2.对于间接继承抽象类的，没有必要一定实现  抽象类的抽象方法，如Test3
3.对于间接继承抽象类的类，如果没有重写抽象类方法，隐式调用父类的实现抽象类方法，如Test3调用了Test2的Sum()方法