namespace e_11 
{ 
 class A 
 { 
  public void F()   //非虚方法 
  { Console.WriteLine("A.F"); } 
  public virtual void G() //虚方法 
  { Console.WriteLine("A.G"); } 
 
 } 
 class B : A     //A类为B类的基类 
 { 
  new public void F()  //隐藏基类的同名非虚方法F(),注意使用new 
  { Console.WriteLine("B.F"); }  
  public override void G() //隐藏基类的同名虚方法G()，注意使用override 
  { Console.WriteLine("B.G"); } 
 } 
 class Test 
 { 
  static void F2(A aA)  //注意，参数为A类引用变量 
  { aA.G(); } 
  static void Main(string[] args) 
  { 
   B b = new B(); 
   A a1 = new A(); 
   A a2 = b;   //允许基类引用变量引用派生类对象，a2引用A类的派生类B的对象b 
   a1.F();    //调用基类A的非虚方法F(),显示A.F 
   a2.F();    //F()为非虚方法，调用基类A的F(),显示A.F 
   b.F();    //F()为非虚方法，调用派生类的F(),显示B.F 
   a1.G();    //G()为虚方法，因a1引用基类A对象，调用基类A的G(),显示A.G 
   a2.G();    //G()为虚方法，因a2引用派生类B对象，调用派生类B的G(),显示B.G 
   F2(a2);    //由于a2引用A类派生类B的对象b，调用派生类B的的G(),显示B.G 
   F2(a1);    //实参为基类A对象，调用A类的函数G(),显示A.G 
  } 
 } 
} 
 

//类的多态性 
namespace e_11 
{ 
 public class Person 
 { 
  private String name = "张三";   //类的成员说明 
  private int age = 12; 
  protected virtual void Display()  //类的虚方法 
  { Console.WriteLine("姓名:{0},年龄:{1}", name, age); } 
  public Person(string Name, int Age)  //构造函数，函数名和类名同名，无返回值 
  { name = Name; age = Age; } 
  static public void DisplayData(Person aPerson) //静态方法 
  { aPerson.Display(); }    //不是静态方法调用实例方法，如写为Display()错误 
 } 
 
 public class Employe : Person   //基类是Person 
 { 
  private string department; 
  private decimal salary; 
  public Employe(string Name, int Age, string D, decimal S) 
   : base(Name, Age) 
  { department = D; salary = S; } 
  protected override void Display()  //重载虚方法，注意用Override 
  { 
   base.Display(); 
   Console.WriteLine("部门:{0}, 薪金:{1}", department, salary); 
  } 
 } 
 
 class Class1 
 { 
  static void Main(string[] args) 
  { 
   Person OnePerson = new Person("李四", 30); 
   Person.DisplayData(OnePerson);  //显示基类的数据 
   Employe OneEmployee = new Employe("王五", 40, "财务", 2000); 
   Person.DisplayData(OneEmployee); //显示派生类数据 
  }//两次调用完全相同的方法，实参不同，实现的功能不同 
 } 
 
}