简单的多态程序

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

namespace VirtualDemo
{
    class A
    {
        public void F() { Console.WriteLine("A.F"); }
        public virtual void G() { Console.WriteLine("A.G"); }
    }
    class B : A
    {
        new public void F() { Console.WriteLine("B.F"); }
        public override void G() { Console.WriteLine("B.G"); }
    }
    class Test
    {
        static void Main()
        {
            B b = new B();
            A a = b;
            a.F();
            b.F();
            a.G();
            b.G();
        }
    }

}

输出结果：

A.F

B.F

B.G

B.G

（疑惑之处：A a=b这个过程，在堆栈上的地址是怎么指向堆的呢，我们经常用抽象类做父类，来引用子类。内存是怎么一个分配过程呢）

------

懂了，其实也可以看成是调用的B的方法，因为B继承了A里面所有的方法。如果重写了就是调用B的，很简单的问题，却让自己给想复杂了。呵呵,

使用 new 关键字时，调用的是新的类成员而不是已被替换的基类成员。这些基类成员称为隐藏成员。如果将派生类的实例强制转换为基类的实例，就仍然可以调用隐藏类成员。例如：本例子中：A a=b,实际是将子类强制性转换成了父类。

public class A
    {
        public virtual void Fun1(int i)
        {
            Console.WriteLine(i);
        }

        public void Fun2(A a)
        {
            a.Fun1(1);
            Fun1(5);
        }
    }


    public class B : A
    {
        public override void Fun1(int i)
        {
            base.Fun1(i + 1);
        }

        public static void Main()
        {
            B b = new B();
            A a = new A();
            a.Fun2(b);
            b.Fun2(a);
            Console.ReadKey();
        }
    }

这道题输出：2 5 1 6