虚方法和隐藏方法被调用的特性[游戏开发前的准备1]

最近学C#看到了一些有意思的编程题目，很适合用于评估对面向对象编程的入门程度，即使对初学者来说理解起来不是很容易。

不过作为程序员真的这样写代码的话一定会被揍，笑。

namespace _16编程题虚方法与隐藏方法1
{
    class Father
    {
        public void A()
        {
            Console.WriteLine("F.A");
        }
        public virtual void B()//virtual必须是父类，override必须是子类，否则报错没有找到合适的方法重写
        {
            Console.WriteLine("F.B");
        }
    }
    class Son : Father
    {
        public new void A()
        {
            Console.WriteLine("S.A");
        }
        public override void B()
        {
            Console.WriteLine("S.B");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Son test1 = new Son();
            Father test2 = test1;// = new Son();
            test1.A();//S.A son声明，子new方法
            test1.B();//S.B son构造，子重写方法
            test2.A();//F.A father声明，父隐藏方法
            test2.B();//S.B son构造，子重写方法
            Console.WriteLine("------");
            Father test3 = new Father();
            test3.A();//F.A father声明，父隐藏方法
            test3.B();//F.B father构造，父虚方法
            //隐藏方法：只有子类声明子对象才会调用子类new后的方法，如果用父类声明子类会调用父类无new方法
            //虚方法：无论是父类声明子对象还是子类声明子对象都调用子类的override方法，只有父类声明父对象才调用父类的virtual方法
            //只需记住隐藏方法看声明，虚方法看构造
            //Son test4 = new Father();//不能son一个new father
            //解释：son相当于已分化的细胞，father相当于未分化的细胞，未分化father可以变成已分化son而已分化son不能变为未分化father
        }
    }
}

namespace _17编程题虚方法与隐藏方法2
{
    public class A
    {
        public virtual void Fun1(int i)
        {
            Console.Write(i+" ");
        }
        public void Fun2(A i)
        {
            i.Fun1(1);
            Fun1(5);
        }
    }
    internal class Program:A
    {
        public override void Fun1(int i)
        {
            base.Fun1(i + 1);
        }
        public new void Fun2(A i)
        {
            i.Fun1(10);
            Fun1(50);
        }
        static void Main(string[] args)
        {
            A a = new A();
            Program b = new Program();
            a.Fun2(b);//2 5 //2 5 //前者代表不在Program里加入new Fun2函数，后者则是加入后
            b.Fun2(a);//1 6 //10 51
            Console.WriteLine();
            a.Fun2(a);//1 5 //1 5
            b.Fun2(b);//2 6 //11 51 //各调各的比较好理解
            Console.WriteLine();
            A c = new Program();
            c.Fun2(a);//1 6 //1 6
            c.Fun2(b);//2 6 //2 6
            c.Fun2(c);//2 6 //2 6 //隐藏方法看声明，因为c是父类A声明的，所以使用的是A里的Fun2函数
            //题目的难点在于声明的类型和调用参数类型的不同，以至于每个父类或子类的Fun2都会经过不同的路径指向父类的Fun1
        }
    }
}

namespace _18编程题虚方法与隐藏方法3
{
    abstract class A
    {
        public A()
        {
            Console.Write("A ");
        }
        public virtual void Fun()
        {
            Console.Write("A.Fun");
        }
    }
    class B:A
    {
        public B()
        {
            Console.Write("B ");
        }
        public new void Fun()
        {
            Console.Write("B.Fun");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            A a = new B();
            a.Fun();//A B A.Fun
            //构造B()时会先调用B(),而调用B()前先会调用父类A()再调用子类B(); 隐藏方法看声明,也就是会调用A的Fun()
        }
    }
}

总结：隐藏方法看声明，虚方法看构造。