我們先看一下結論：
override
1. override是派生類用來重寫基類中方法的；

2. override不能重寫非虛方法和靜態方法；

3. override只能重寫用virtual、abstract、override修飾的方法；

4. 不能使用修飾符 new、static、virtual 或 abstract 來修改 override 方法。

new
1. new是派生類用來隱藏基類中的方法的；也就是說在派生類中“看不到”基類中的方法，說白了，其實就是基類和派生類的這2個函式，雖然名字相同，但可以看成是名字不一樣的2個函式，沒啥聯絡，基類和派生類的函式是共存的。

2. 如果要在派生類中隱藏（不是重寫）基類中的方法，而沒有使用new關鍵字，編譯時會出現一個警告，提示如果是要隱藏基類中的方法，請使用new關鍵字；

3. 派生類可以隱藏基類中的虛方法，也可以隱藏基類中的普通方法。

4. 如果在派生類中用private來修飾new 方法，那麼只在該派生類中隱藏了基類中的方法，在該派生類之外，相當於沒有隱藏基類中的方法；

5. 如果在派生類中隱藏了基類中的方法，在該派生類的派生類中，將延續對該派生類對基類方法的隱藏。

現在不在狀態或者比較暈的童鞋，不用擔心，下面我用簡單的例子來講解一下，便於理解。

override的例子
public class A
{
public A()
{
Console.WriteLine('A');
}
public virtual void Fun()
{
Console.WriteLine("A.Fun()");
}
}

public class B : A
{
public B()
{
Console.WriteLine('B');
}

public override void Fun()
{
Console.WriteLine("B.Fun()");
}
}
宣告B型別的物件：

B test = new B();
test.Fun();

輸出結果是：

A
B
B.Fun()

該結果中，先輸出A，在輸出B，說明初始化的時候，先執行基類，再執行化子類的建構函式

宣告A型別的物件：

A test = new B();
test.Fun();

執行結果：

A
B
B.Fun()

說明無論是父型別還是子型別的物件 ，當使用override時，父類的虛擬函式完全被子類的函式給“覆蓋”了。這個例子相信是No Problem的。

new的例子
public class A
{
public A()
{
Console.WriteLine('A');
}
public virtual void Fun()
{
Console.WriteLine("A.Fun()");
}
}

public class B : A
{
public B()
{
Console.WriteLine('B');
}

public new void Fun()
{
Console.WriteLine("B.Fun()");
}
}
宣告B型別的物件：

B test = new B();
test.Fun();

輸出結果是：

A
B
B.Fun() ----此時與override的效果相同

宣告A型別的物件：

A test = new B();
test.Fun();

執行結果：

A
B
A.Fun() ----此時，與override的情況不一樣了。。。

簡單的結論：

1.new宣告的方法，當使用子類的型別來呼叫的時候，它會執行子類中的函式，當型別是基類的話 ，則使用基類的函式來執行，可以簡單的記憶：

override--覆蓋（父類的沒了，始終是兒子），new--新的（父子共存）

PS:只有使用virtual定義基類中的函式，並使用override標記子類的函式，才可以達到多型類----始終呼叫子類的方法

2.子類中override父類的方法，父類的方法一定要是virtual，而在子類中new父類的方法，父類的方法不一定要是virtual

3.抽象類中的抽象方法，必須要被子類override，不能new

4.override可以與sealed關鍵詞連用： sealed override void F()，而new不行。被sealed修飾過的方法，不能再被子類重寫

常見的面試題

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);
}
}
B b = new B();
A a = new A();
a.Fun2(b);
b.Fun2(a);

執行上面語句，執行結果是什麼？

先分析a.Fun2(b)：傳入的引數是B型別的，因此a.Fun1(1)執行的是B型別物件的Fun1方法，執行結果是2

然後執行Fun1(5)，由於執行的是A型別物件的Fun2方法，Fun1自然就是A中的Fun1，執行結果是5

再分析b.Fun2(a)：傳入的引數是A型別的，因此a.Fun1(1)執行的是A型別物件的Fun1方法，執行結果是1

然後執行Fun1(5)，由於執行的是B型別物件的Fun2方法，此時的Fun1已經被B覆蓋掉了，因此執行的是被覆蓋後的方法，執行結果是6

那麼如果把B類中的override改成new，情況會是什麼樣呢？

由於public void Fun2(A a)的引數型別始終是A型別（當傳入B型別時，會轉成A型別，相當於A a = new B()的效果），而用new不會覆蓋父類的方法，因此結果是：

1

5

1

5

拓展面試題
class A
{
public virtual void Func() // 注意virtual,表明這是一個虛擬函式
{
Console.WriteLine("Func In A");
}
}
class B : A // 注意B是從A類繼承,所以A是父類,B是子類
{
public override void Func() // 注意override ,表明重新實現了虛擬函式
{
Console.WriteLine("Func In B");
}
}
class C : B // 注意C是從B類繼承,所以B是父類,C是子類
{
}
class D : A // 注意D是從A類繼承,所以A是父類,D是子類
{
public new void Func() // 注意new，表明覆蓋父類裡的同名類，而不是重新實現
{
Console.WriteLine("Func In D");
}
}
class E : D // 注意E是從D類繼承,所以D是父類,E是子類
{

}
class F : A
{
private new void Func() //注意new關鍵字前有private修飾符，故該隱藏只在F類內有效
{
Console.WriteLine("Func In F");
}

public void Func2()
{
Func(); //在F類內隱藏了基類的Func方法，故此處呼叫的private new void Func()
}
}


static void Main(string[] args)
{
A a; // 定義一個a這個A類的物件.這個A就是a的申明類
A b; // 定義一個b這個A類的物件.這個A就是b的申明類
A c; // 定義一個c這個A類的物件.這個A就是c的申明類
A d; // 定義一個d這個A類的物件.這個A就是d的申明類
A e; // 定義一個e這個A類的物件.這個A就是e的申明類
A f; // 定義一個f這個A類的物件.這個A就是f的申明類
a = new A(); // 例項化a物件,A是a的例項類
b = new B(); // 例項化b物件,B是b的例項類
c = new C(); // 例項化c物件,C是c的例項類
d = new D(); // 例項化d物件,D是d的例項類
e = new E(); // 例項化e物件,E是e的例項類
f = new F(); // 例項化f物件,F是f的例項類
Console.WriteLine("a.Func();");
a.Func(); // 執行a.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類A，就為本身 4.執行例項類A中的方法 5.輸出結果 Func In A
Console.WriteLine("b.Func();");
b.Func(); // 執行b.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類B，有過載的 4.執行例項類B中的方法 5.輸出結果 Func In B
Console.WriteLine("c.Func();");
c.Func(); // 執行c.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類C，無過載的 4.轉去檢查類C的父類B，有過載的 5.執行父類B中的Func方法 5.輸出結果 Func In B
Console.WriteLine("d.Func();");
d.Func(); // 執行d.Func：1.先檢查申明類A 2.檢查到是虛擬方法 3.轉去檢查例項類D，無過載的（這個地方要注意了，雖然D裡有實現Func()，但沒有使用override關鍵字，所以不會被認為是過載） 4.轉去檢查類D的父類A，就為本身 5.執行父類A中的Func方法 5.輸出結果 Func In A
Console.WriteLine("e.Func();");
e.Func(); // 執行e.Func：E繼承D，E.Func沒有重寫父類中的方法，相當於執行父類D中的Func方法，輸出結果 Func In A
Console.WriteLine("f.Func();");
f.Func(); // 執行f.Func：F類中雖然隱藏了基類中的Func方法，但是有private修飾符，該隱藏只在F類範圍內有效。執行f.Func相當於執行其基類中的Func方法，輸出結果 Func In A

D d1 = new D();
Console.WriteLine("d1.Func();");
d1.Func(); // 執行D類裡的Func()，輸出結果 Func In D

E e1 = new E();
Console.WriteLine("e1.Func();");
e1.Func(); // 執行E類裡的Func()，輸出結果 Func In D

F f1 = new F();
Console.WriteLine("f1.Func();");
f1.Func(); // 執行F類裡的Func()，輸出結果 Func In A
Console.WriteLine("f1.Func2();");
f1.Func2(); // 執行F類裡的Func2()，輸出結果 Func In F

Console.ReadLine();
}

————————————————
版權宣告：本文為CSDN博主「HawkJony」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處連結及本宣告。
原文連結：https://blog.csdn.net/qiaoquan3/article/details/75529226