若一個實例方法宣告前面有virtual關鍵字，那麼這個方法就是虛方法。
虛方法與非虛方法的最大不同是，虛方法的實作可以由派生類別所取代，這種取代是透過方法的重寫實現的（以後再講）
虛方法的特點:
虛方法前不允許有static,abstract,或override修飾符
虛方法不能是私有的，因此不能使用private修飾符
虛方法的執行：
我們知道一般函數在編譯時就靜態地編譯到了執行文件中，其相對地址在程式運行期間是不發生變化的，
而虛函數在編譯期間是不被靜態編譯的，它的相對地址是不確定的，它會根據運行時期對象實例來動態判斷要調用的函數，
其中那個申明時定義的類別叫申明類，那個執行時實例化的類別叫做實例類別。
如：A a =new B(); 其中A是申明類，B是實例類。
1.當呼叫一個物件的函數時，系統會直接去檢查這個物件申明定義的類，即申明類，看所呼叫的函數是否為虛函數；
2.如果不是虛函數，那麼它就直接執行該函數。而如果是一個虛函數，那麼這個時候它就不會立刻執行該函數了，而是開始檢查物件的實例類別。
3.在這個實例類別裡，他會檢查這個實例類別的定義中是否有實現該虛函數或重新實作該虛函數（透過override關鍵字）的方法，
如果有，它就不會再找了，而是馬上執行該實例類別中實現的虛擬函數的方法。而如果沒有的話，系統就會不停地往上找實例類的父類，
並對父類重複剛才在實例類裡的檢查，直到找到第一個重載了該虛函數的父類為止，然後執行該父類別裡重載後的函數。
例1：
class A
{
public virtual void Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class Program
{
static void Main(string[] args)
{
A a=new A(); // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,A是a的实例类
a.Sum();
Console.Read();
}
}執行a.Sum：
1.先檢查申明類別A 2.檢查到是sum是虛擬方法 3.轉去檢查實例類別A，結果是題本身
4.執行實例類別A中實作Sum的方法 5.輸出結果I am A Class,I am virtual sum().
例2：
class A
{
public virtual void Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
public override void Sum() // 重新实现了虚函数
{
Console.WriteLine("I am B Class,I am override sum().");
}
}
class Program
{
static void Main(string[] args)
{
A a=new B(); // 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,B是a的实例类
a.Sum();
Console.Read();
}
}執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類別B，有重寫的方法4.執行實例類別B中的方法 5.輸出結果I am B Class,I am override sum().
class A
{
public virtual void Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
public override void Sum() // 重新实现了虚函数
{
Console.WriteLine("I am B Class,I am override sum().");
}
}
class C : B
{
}
class Program
{
static void Main(string[] args)
{
A a=new C();// 定义一个a这个A类的对象.这个A就是a的申明类，实例化a对象,C是a的实例类
a.Sum();
Console.Read();
}
}class A
{
public virtual void Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
public new void Sum() //覆盖父类里的同名函数，而不是重新实现
{
Console.WriteLine("I am B Class,I am new sum().");
}
}
class Program
{
static void Main(string[] args)
{
A a=new B();
a.Sum();
Console.Read();
}
}class A
{
public virtual void Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
public new void Sum() //覆盖父类里的同名函数，而不是重新实现
{
Console.WriteLine("I am B Class,I am new sum().");
}
}
class Program
{
static void Main(string[] args)
{
B b=new B();
b.Sum();
Console.Read();
}
}class A
{
public virtual void PrintFriends()
{
Console.WriteLine("A.PrintFriends()");
}
}
abstract class B : A
{
public abstract override void PrintFriends(); //使用override 修饰符，表示抽象重写了基类中该函数的实现
}
abstract class C : A
{
public abstract new void PrintFriends(); //使用 new 修饰符显式声明，表示隐藏了基类中该函数的实现
}class A
{
public virtual void Fun()
{
Console.WriteLine("I am A.");
}
}
sealed class Program:A
{
public override void Fun()
{
Console.WriteLine("I am B.");
}
static void Main(string[] args)
{
Program p = new Program();
p.Fun();
Console.Read();
}
}
