若一個實例方法聲明前帶有virtual關鍵字，那么這個方法就是虛方法。
虛方法與非虛方法的最大不同是，虛方法的實現可以由派生類所取代，這種取代是通過方法的重寫實現的（以后再講）
虛方法的特點:
虛方法前不允許有static,abstract,或override修飾符
虛方法不能是私有的，因此不能使用private修飾符
虛方法的執行：
我們知道一般函數在編譯時就靜態地編譯到了執行文件中，其相對地址在程序運行期間是不發生變化的，
而虛函數在編譯期間是不被靜態編譯的，它的相對地址是不確定的，它會根據運行時期對象實例來動態判斷要調用的函數，
其中那個申明時定義的類叫申明類，那個執行時實例化的類叫實例類。
如：A a =new B(); 其中A是申明類，B是實例類。
1.當調用一個對象的函數時，系統會直接去檢查這個對象申明定義的類，即申明類，看所調用的函數是否為虛函數；
2.如果不是虛函數，那么它就直接執行該函數。而如果是一個虛函數，那么這個時候它就不會立刻執行該函數了，而是開始檢查對象的實例類。
3.在這個實例類里，他會檢查這個實例類的定義中是否有實現該虛函數或者重新實現該虛函數（通過override關鍵字）的方法，
如果有，它就不會再找了，而是馬上執行該實例類中實現的虛函數的方法。而如果沒有的話，系統就會不停地往上找實例類的父類，
并對父類重復剛才在實例類里的檢查，直到找到第一個重載了該虛函數的父類為止，然后執行該父類里重載后的函數。
例1：
class A
{
publicvirtualvoid Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class Program
{
staticvoid 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
{
publicvirtualvoid Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
publicoverridevoid Sum() // 重新實現了虛函數
{
Console.WriteLine("I am B Class,I am override sum().");
}
}
class Program
{
staticvoid Main(string[] args)
{
A a=new B(); // 定義一個a這個A類的對象.這個A就是a的申明類，實例化a對象,B是a的實例類
a.Sum();
Console.Read();
}
}
執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類B，有重寫的方法 4.執行實例類B中的方法 5.輸出結果 I am B Class,I am override sum().
例3：
class A
{
publicvirtualvoid Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
publicoverridevoid Sum() // 重新實現了虛函數
{
Console.WriteLine("I am B Class,I am override sum().");
}
}
class C : B
{
}
class Program
{
staticvoid Main(string[] args)
{
A a=new C();// 定義一個a這個A類的對象.這個A就是a的申明類，實例化a對象,C是a的實例類
a.Sum();
Console.Read();
}
}
執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類C，無重寫的方法 4.轉去檢查類C的父類B，有重寫的方法
5.執行父類B中的Sum方法 6.輸出結果 I am B Class,I am override sum().
例4：class A
{
publicvirtualvoid Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
publicnewvoid Sum() //覆蓋父類里的同名函數，而不是重新實現
{
Console.WriteLine("I am B Class,I am new sum().");
}
}
class Program
{
staticvoid Main(string[] args)
{
A a=new B();
a.Sum();
Console.Read();
}
}
執行a.Sum：
1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查實例類B，無重寫的（這個地方要注意了，雖然B里有實現Sum()，但沒有使用override關鍵字，所以不會被認為是重寫） 4.轉去檢查類B的父類A，就為本身 5.執行父類A中的Sum方法 6.輸出結果 I am A Class,I am virtual sum().
那么如果在例4里，申明的是類B呢？
class A
{
publicvirtualvoid Sum()
{
Console.WriteLine("I am A Class,I am virtual sum().");
}
}
class B : A
{
publicnewvoid Sum() //覆蓋父類里的同名函數，而不是重新實現
{
Console.WriteLine("I am B Class,I am new sum().");
}
}
class Program
{
staticvoid Main(string[] args)
{
B b=new B();
b.Sum();
Console.Read();
}
}
執行B類里的Sum()，輸出結果I am B Class,I am new sum().
可以使用抽象函數重寫基類中的虛函數嗎？
答案是可以的。
class A
{
publicvirtualvoid PrintFriends()
{
Console.WriteLine("A.PrintFriends()");
}
}
abstractclass B : A
{
public abstract override void PrintFriends(); //使用override 修飾符，表示抽象重寫了基類中該函數的實現
}
abstract class C : A
{
public abstract new void PrintFriends(); //使用 new 修飾符顯式聲明，表示隱藏了基類中該函數的實現
}
密封類可以有虛函數嗎？
可以，基類中的虛函數將隱式的轉化為非虛函數，但密封類本身不能再增加新的虛函數
class A
{
publicvirtualvoid Fun()
{
Console.WriteLine("I am A.");
}
}
sealedclass Program:A
{
public override void Fun()
{
Console.WriteLine("I am B.");
}
staticvoid Main(string[] args)
{
Program p =new Program();
p.Fun();
Console.Read();
}
}
