学习C#类的实例化 和方法的问题

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

namespace ConsoleApplication1
{
    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 virtual void G()
        {
            Console.WriteLine("B.G");
        }
    }
    class test
    {
        static void Main(string[] args)
        {
            B b = new B();
            A a = b;
            a.F();
            b.F();
            a.G();
            b.G();
        }
    }
}
问题如下：
1:B b = new B();这是类B 实例化b
  A a = b;  那么这个语句是么意思？
2：     a.F();
        b.F();
        a.G();
        b.G();
        a,b 都是类的实例化对象，我认为类属性可以这样写a.F();  类的方法也可以这样写吗？
3:这个程序的执行结果是：
A.F
B.F
A.G
B.G
但是 书上说是：
A.F
B.F
B.G
B.G
具体应该是那一个呢？为什么？

答案---------->>
A a = b;这个吗就是    基类对象引用子类的对象
结果应该是:
A.F
B.F
A.G
B.G
如果是你们书上的这种结果:应该把子类的
        public virtual void G()
        {
        Console.WriteLine("B.G");
        }
修改为
        public override void G()
        {
        Console.WriteLine("B.G");
        }

    就是你们书上这种结果了

方法的覆盖：指派生类覆盖基类的同名方法，有二种方法
1:第一种是在派生类要覆盖的方法前面加new修饰，而基类不需要作任何改动。
这种方法的缺点是不能实现多态。例：
class A
{
  public void Method()  //无需任何修饰
  {
  ...
  }
}
class B: A   //从基类继承
{
  new public void Method() //覆盖基类的同名方法
  {
  ...
  }
}
class TestClass
{
  A Instance = new B();
  Instance.Method();  //这时将调用类A的Method方法，而不是类B的Method方法
}
2:第二种是在派生类要覆盖的方法前面加override修饰，而基类的同名方法前面加virtual修饰。
这样就能实现多态，例：
class A
{
  virtual public void Method()   //基类定义虚方法
  {      //虚拟方法不能定义为private，因为private成员对派生类是无法访问的
  ...
  }
}

class B: A     //从基类继承
{
  override public void Method()   //派生类覆盖基类的同名虚方法
  {
  ...
  }
}

class TestClass
{
  protected void Test()
  {
    A Instance = new B();   //定义一个实例，类型为基类，从派生类创建
                            //派生类总是能够向上转换为其基类
    Instance.Method();      //将调用派生类B的Method方法，而不是基类的，这就是多态
  }
}

说明：new修饰的方法覆盖不能实现多态的原因，是因为使用new时编译器只会实现早期绑定（early binding）。
即调用的方法在编译时就决定了：编译器看到Instance.Method()而Instance的类是A，就会调用类A的Method()方法。
override修饰的方法覆盖可以实现多态的原因，是因为实现了后期绑定（late binding）。使用override时强制编译器在运行时根据类的真正类型正确调用相应的方法，而不是在编译时。而基类的同名方法必须加virtual修饰。