什么是多態？它的實現機制是什么呢？重載和重寫的區別在那里？這就是這一次我們要回顧的四個十分重要的概念：繼承、多態、重載和重寫。
繼承(inheritance)
簡單的說，繼承就是在一個現有類型的基礎上，通過增加新的方法或者重定義已有方法（下面會講到，這種方式叫重寫）的方式，產生一個新的類型。繼承是面向對象的三個基本特征--封裝、繼承、多態的其中之一，我們在使用JAVA時編寫的每一個類都是在繼承，因為在JAVA語言中，java.lang.Object類是所有類最根本的基類（或者叫父類、超類），如果我們新定義的一個類沒有明確地指定繼承自哪個基類，那么JAVA就會默認為它是繼承自Object類的。
我們可以把JAVA中的類分為以下三種：
類：使用class定義且不含有抽象方法的類。
抽象類：使用abstract class定義的類，它可以含有，也可以不含有抽象方法。
接口：使用interface定義的類。
在這三種類型之間存在下面的繼承規律：
類可以繼承（extends）類，可以繼承（extends）抽象類，可以繼承（implements）接口。
抽象類可以繼承（extends）類，可以繼承（extends）抽象類，可以繼承（implements）接口。
接口只能繼承（extends）接口。
請注意上面三條規律中每種繼承情況下使用的不同的關鍵字extends和implements，它們是不可以隨意替換的。大家知道，一個普通類繼承一個接口后，必須實現這個接口中定義的所有方法，否則就只能被定義為抽象類。我在這里之所以沒有對implements關鍵字使用“實現”這種說法是因為從概念上來說它也是表示一種繼承關系，而且對于抽象類implements接口的情況下，它并不是一定要實現這個接口定義的任何方法，因此使用繼承的說法更為合理一些。
以上三條規律同時遵守下面這些約束：
類和抽象類都只能最多繼承一個類，或者最多繼承一個抽象類，并且這兩種情況是互斥的，也就是說它們要么繼承一個類，要么繼承一個抽象類。
類、抽象類和接口在繼承接口時，不受數量的約束，理論上可以繼承無限多個接口。當然，對于類來說，它必須實現它所繼承的所有接口中定義的全部方法。
抽象類繼承抽象類，或者實現接口時，可以部分、全部或者完全不實現父類抽象類的抽象（abstract）方法，或者父類接口中定義的接口。
類繼承抽象類，或者實現接口時，必須全部實現父類抽象類的全部抽象（abstract）方法，或者父類接口中定義的全部接口。
繼承給我們的編程帶來的好處就是對原有類的復用（重用）。就像模塊的復用一樣，類的復用可以提高我們的開發效率，實際上，模塊的復用是大量類的復用疊加后的效果。除了繼承之外，我們還可以使用組合的方式來復用類。所謂組合就是把原有類定義為新類的一個屬性，通過在新類中調用原有類的方法來實現復用。如果新定義的類型與原有類型之間不存在被包含的關系，也就是說，從抽象概念上來講，新定義類型所代表的事物并不是原有類型所代表事物的一種，比如黃種人是人類的一種，它們之間存在包含與被包含的關系，那么這時組合就是實現復用更好的選擇。下面這個例子就是組合方式的一個簡單示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class Sub { private Parent p = new Parent(); public void doSomething() { // 復用Parent類的方法 p.method(); // other code } } class Parent { public void method() { // do something here } } |
當然，為了使代碼更加有效，我們也可以在需要使用到原有類型（比如Parent p）時，才對它進行初始化。
使用繼承和組合復用原有的類，都是一種增量式的開發模式，這種方式帶來的好處是不需要修改原有的代碼，因此不會給原有代碼帶來新的BUG，也不用因為對原有代碼的修改而重新進行測試，這對我們的開發顯然是有益的。因此，如果我們是在維護或者改造一個原有的系統或模塊，尤其是對它們的了解不是很透徹的時候，就可以選擇增量開發的模式，這不僅可以大大提高我們的開發效率，也可以規避由于對原有代碼的修改而帶來的風險。
多態(Polymorphism)
多態是又一個重要的基本概念，上面說到了，它是面向對象的三個基本特征之一。究竟什么是多態呢？我們先看看下面的例子，來幫助理解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
//汽車接口 interface Car { // 汽車名稱 String getName(); // 獲得汽車售價 int getPrice(); } // 寶馬 class BMW implements Car { public String getName() { return "BMW"; } public int getPrice() { return 300000; } } // 奇瑞QQ class CheryQQ implements Car { public String getName() { return "CheryQQ"; } public int getPrice() { return 20000; } } // 汽車出售店 public class CarShop { // 售車收入 private int money = 0; // 賣出一部車 public void sellCar(Car car) { System.out.println("車型：" + car.getName() + " 單價：" + car.getPrice()); // 增加賣出車售價的收入 money += car.getPrice(); } // 售車總收入 public int getMoney() { return money; } public static void main(String[] args) { CarShop aShop = new CarShop(); // 賣出一輛寶馬 aShop.sellCar(new BMW()); // 賣出一輛奇瑞QQ aShop.sellCar(new CheryQQ()); System.out.println("總收入：" + aShop.getMoney()); } } |
運行結果：
車型：BMW 單價：300000
車型：CheryQQ 單價：20000
總收入：320000
繼承是多態得以實現的基礎。從字面上理解，多態就是一種類型（都是Car類型）表現出多種狀態（寶馬汽車的名稱是BMW，售價是300000；奇瑞汽車的名稱是CheryQQ，售價是2000）。將一個方法調用同這個方法所屬的主體（也就是對象或類）關聯起來叫做綁定，分前期綁定和后期綁定兩種。下面解釋一下它們的定義：
前期綁定：在程序運行之前進行綁定，由編譯器和連接程序實現，又叫做靜態綁定。比如static方法和final方法，注意，這里也包括private方法，因為它是隱式final的。
后期綁定：在運行時根據對象的類型進行綁定，由方法調用機制實現，因此又叫做動態綁定，或者運行時綁定。除了前期綁定外的所有方法都屬于后期綁定。
多態就是在后期綁定這種機制上實現的。多態給我們帶來的好處是消除了類之間的耦合關系，使程序更容易擴展。比如在上例中，新增加一種類型汽車的銷售，只需要讓新定義的類繼承Car類并實現它的所有方法，而無需對原有代碼做任何修改，CarShop類的sellCar(Car car)方法就可以處理新的車型了。新增代碼如下：
|
1
2
3
4
5
6
7
8
9
10
|
// 桑塔納汽車 class Santana implements Car { public String getName() { return "Santana"; } public int getPrice() { return 80000; } } |
重載(overloading)和重寫(overriding)
重載和重寫都是針對方法的概念，在弄清楚這兩個概念之前，我們先來了解一下什么叫方法的型構（英文名是signature，有的譯作“簽名”，雖然它被使用的較為廣泛，但是這個翻譯不準確的）。型構就是指方法的組成結構，具體包括方法的名稱和參數，涵蓋參數的數量、類型以及出現的順序，但是不包括方法的返回值類型，訪問權限修飾符，以及abstract、static、final等修飾符。比如下面兩個就是具有相同型構的方法：
|
1
2
3
4
5
6
7
|
public void method(int i, String s) { // do something } public String method(int i, String s) { // do something } |
而這兩個就是具有不同型構的方法：
|
1
2
3
4
5
6
7
|
public void method(int i, String s) { // do something } public void method(String s, int i) { // do something } |
了解完型構的概念后我們再來看看重載和重寫，請看它們的定義：
重寫，英文名是overriding，是指在繼承情況下，子類中定義了與其基類中方法具有相同型構的新方法，就叫做子類把基類的方法重寫了。這是實現多態必須的步驟。
重載，英文名是overloading，是指在同一個類中定義了一個以上具有相同名稱，但是型構不同的方法。在同一個類中，是不允許定義多于一個的具有相同型構的方法的。
我們來考慮一個有趣的問題：構造器可以被重載嗎？答案當然是可以的，我們在實際的編程中也經常這么做。實際上構造器也是一個方法，構造器名就是方法名，構造器參數就是方法參數，而它的返回值就是新創建的類的實例。但是構造器卻不可以被子類重寫，因為子類無法定義與基類具有相同型構的構造器。
重載、覆蓋、多態與函數隱藏
經常看到C++的一些初學者對于重載、覆蓋、多態與函數隱藏的模糊理解。在這里寫一點自己的見解，希望能夠C++初學者解惑。
要弄清楚重載、覆蓋、多態與函數隱藏之間的復雜且微妙關系之前，我們首先要來回顧一下重載覆蓋等基本概念。
首先，我們來看一個非常簡單的例子，理解一下什么叫函數隱藏hide。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#include <iostream>using namespace std;class Base{public: void fun() { cout << "Base::fun()" << endl; }};class Derive : public Base{public: void fun(int i) { cout << "Derive::fun()" << endl; }};int main(){ Derive d; //下面一句錯誤，故屏蔽掉 //d.fun();error C2660: 'fun' : function does not take 0 parameters d.fun(1); Derive *pd =new Derive(); //下面一句錯誤，故屏蔽掉 //pd->fun();error C2660: 'fun' : function does not take 0 parameters pd->fun(1); delete pd; return 0;} |
/*在不同的非命名空間作用域里的函數不構成重載,子類和父類是不同的兩個作用域。
在本例中,兩個函數在不同作用域中,故不夠成重載,除非這個作用域是命名空間作用域。*/
在這個例子中，函數不是重載overload，也不是覆蓋override，而是隱藏hide。
接下來的5個例子具體說明一下什么叫隱藏
例1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#include <iostream>using namespace std;class Basic{public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload};class Derive :public Basic{public: void fun2(){cout << "Derive::fun2()" << endl;}};int main(){ Derive d; d.fun();//正確，派生類沒有與基類同名函數聲明，則基類中的所有同名重載函數都會作為候選函數。 d.fun(1);//正確，派生類沒有與基類同名函數聲明，則基類中的所有同名重載函數都會作為候選函數。 return 0;} |
例2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <iostream>using namespace std;class Basic{public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload};class Derive :public Basic{public: //新的函數版本,基類所有的重載版本都被屏蔽,在這里,我們稱之為函數隱藏hide //派生類中有基類的同名函數的聲明，則基類中的同名函數不會作為候選函數，即使基類有不同的參數表的多個版本的重載函數。 void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;} void fun2(){cout << "Derive::fun2()" << endl;}};int main(){ Derive d; d.fun(1,2); //下面一句錯誤，故屏蔽掉 //d.fun();error C2660: 'fun' : function does not take 0 parameters return 0;} |
例3
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <iostream>using namespace std;class Basic{public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload};class Derive :public Basic{public: //覆蓋override基類的其中一個函數版本,同樣基類所有的重載版本都被隱藏hide //派生類中有基類的同名函數的聲明，則基類中的同名函數不會作為候選函數，即使基類有不同的參數表的多個版本的重載函數。 void fun(){cout << "Derive::fun()" << endl;} void fun2(){cout << "Derive::fun2()" << endl;}};int main(){ Derive d; d.fun(); //下面一句錯誤，故屏蔽掉 //d.fun(1);error C2660: 'fun' : function does not take 1 parameters return 0;} |
例4
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#include <iostream>using namespace std;class Basic{public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload};class Derive :public Basic{public: using Basic::fun; void fun(){cout << "Derive::fun()" << endl;} void fun2(){cout << "Derive::fun2()" << endl;}};int main(){ Derive d; d.fun();//正確 d.fun(1);//正確 return 0;}/*輸出結果Derive::fun()Base::fun(int i)Press any key to continue*/ |
例5
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#include <iostream>using namespace std;class Basic{public: void fun(){cout << "Base::fun()" << endl;}//overload void fun(int i){cout << "Base::fun(int i)" << endl;}//overload};class Derive :public Basic{public: using Basic::fun; void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;} void fun2(){cout << "Derive::fun2()" << endl;}};int main(){ Derive d; d.fun();//正確 d.fun(1);//正確 d.fun(1,2);//正確 return 0;}/*輸出結果Base::fun()Base::fun(int i)Derive::fun(int i,int j)Press any key to continue*/ |
好了，我們先來一個小小的總結重載與覆蓋兩者之間的特征
重載overload的特征：
n 相同的范圍(在同一個類中)；
n 函數名相同參數不同；
n virtual 關鍵字可有可無。
覆蓋override是指派生類函數覆蓋基類函數，覆蓋的特征是：
n 不同的范圍(分別位于派生類與基類)；
n 函數名和參數都相同；
n 基類函數必須有virtual 關鍵字。(若沒有virtual 關鍵字則稱之為隱藏hide)
如果基類有某個函數的多個重載(overload)版本，而你在派生類中重寫(override)了基類中的一個或多個函數版本，或是在派生類中重新添加了新的函數版本(函數名相同，參數不同)，則所有基類的重載版本都被屏蔽，在這里我們稱之為隱藏hide。所以，在一般情況下，你想在派生類中使用新的函數版本又想使用基類的函數版本時，你應該在派生類中重寫基類中的所有重載版本。你若是不想重寫基類的重載的函數版本，則你應該使用例4或例5方式，顯式聲明基類名字空間作用域。
事實上，C++編譯器認為，相同函數名不同參數的函數之間根本沒有什么關系，它們根本就是兩個毫不相關的函數。只是C++語言為了模擬現實世界，為了讓程序員更直觀的思維處理現實世界中的問題，才引入了重載和覆蓋的概念。重載是在相同名字空間作用域下，而覆蓋則是在不同的名字空間作用域下，比如基類和派生類即為兩個不同的名字空間作用域。在繼承過程中，若發生派生類與基類函數同名問題時，便會發生基類函數的隱藏。當然，這里討論的情況是基類函數前面沒有virtual 關鍵字。在有virtual 關鍵字關鍵字時的情形我們另做討論。
繼承類重寫了基類的某一函數版本，以產生自己功能的接口。此時C++編繹器認為，你現在既然要使用派生類的自己重新改寫的接口，那我基類的接口就不提供給你了(當然你可以用顯式聲明名字空間作用域的方法，見[C++基礎]重載、覆蓋、多態與函數隱藏(1))。而不會理會你基類的接口是有重載特性的。若是你要在派生類里繼續保持重載的特性，那你就自己再給出接口重載的特性吧。所以在派生類里，只要函數名一樣，基類的函數版本就會被無情地屏蔽。在編繹器中，屏蔽是通過名字空間作用域實現的。
所以，在派生類中要保持基類的函數重載版本，就應該重寫所有基類的重載版本。重載只在當前類中有效，繼承會失去函數重載的特性。也就是說，要把基類的重載函數放在繼承的派生類里，就必須重寫。
這里“隱藏”是指派生類的函數屏蔽了與其同名的基類函數，具體規則我們也來做一小結：
n 如果派生類的函數與基類的函數同名，但是參數不同。此時，若基類無virtual關鍵字，基類的函數將被隱藏。(注意別與重載混淆，雖然函數名相同參數不同應稱之為重載，但這里不能理解為重載，因為派生類和基類不在同一名字空間作用域內。這里理解為隱藏)
n 如果派生類的函數與基類的函數同名，但是參數不同。此時，若基類有virtual關鍵字，基類的函數將被隱式繼承到派生類的vtable中。此時派生類vtable中的函數指向基類版本的函數地址。同時這個新的函數版本添加到派生類中，作為派生類的重載版本。但在基類指針實現多態調用函數方法時，這個新的派生類函數版本將會被隱藏。
n 如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數沒有virtual關鍵字。此時，基類的函數被隱藏。(注意別與覆蓋混淆，這里理解為隱藏)。
n 如果派生類的函數與基類的函數同名，并且參數也相同，但是基類函數有virtual關鍵字。此時，基類的函數不會被“隱藏”。(在這里，你要理解為覆蓋哦^_^)。
插曲：基類函數前沒有virtual關鍵字時，我們要重寫更為順口些，在有virtual關鍵字時，我們叫覆蓋更為合理些，戒此，我也希望大家能夠更好的理解C++中一些微妙的東西。費話少說，我們舉例說明吧。
例6
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#include <iostream>using namespace std; class Base{public: virtual void fun() { cout << "Base::fun()" << endl; }//overload virtual void fun(int i) { cout << "Base::fun(int i)" << endl; }//overload}; class Derive : public Base{public: void fun() { cout << "Derive::fun()" << endl; }//override void fun(int i) { cout << "Derive::fun(int i)" << endl; }//override void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <<endl;}//overload}; int main(){ Base *pb = new Derive(); pb->fun(); pb->fun(1); //下面一句錯誤，故屏蔽掉 //pb->fun(1,2);virtual函數不能進行overload,error C2661: 'fun' : no overloaded function takes 2 parameters cout << endl; Derive *pd = new Derive(); pd->fun(); pd->fun(1); pd->fun(1,2);//overload delete pb; delete pd; return 0;}/* |
輸出結果
Derive::fun()
Derive::fun(int i)
Derive::fun()
Derive::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/
例7-1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }}; class Derive : public Base{}; int main(){ Base *pb = new Derive(); pb->fun(1);//Base::fun(int i) delete pb; return 0;} |
例7-2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }}; class Derive : public Base{public: void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main(){ Base *pb = new Derive(); pb->fun(1);//Base::fun(int i) pb->fun((double)0.01);//Base::fun(int i) delete pb; return 0;} |
例8-1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }}; class Derive : public Base{public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }}; int main(){ Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) delete pb; return 0;} |
例8-2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }}; class Derive : public Base{public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; } void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main(){ Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) pb->fun((double)0.01);//Derive::fun(int i) delete pb; return 0;} |
例9
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }};class Derive : public Base{public: void fun(int i){ cout <<"Derive::fun(int i)"<< endl; } void fun(char c){ cout <<"Derive::fun(char c)"<< endl; } void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } };int main(){ Base *pb = new Derive(); pb->fun(1);//Derive::fun(int i) pb->fun('a');//Derive::fun(int i) pb->fun((double)0.01);//Derive::fun(int i) Derive *pd =new Derive(); pd->fun(1);//Derive::fun(int i) //overload pd->fun('a');//Derive::fun(char c) //overload pd->fun(0.01);//Derive::fun(double d) delete pb; delete pd; return 0;} |
例7-1和例8-1很好理解，我把這兩個例子放在這里，是讓大家作一個比較擺了，也是為了幫助大家更好的理解：
n 例7-1中，派生類沒有覆蓋基類的虛函數，此時派生類的vtable中的函數指針指向的地址就是基類的虛函數地址。
n 例8-1中，派生類覆蓋了基類的虛函數，此時派生類的vtable中的函數指針指向的地址就是派生類自己的重寫的虛函數地址。
在例7-2和8-2看起來有點怪怪，其實，你按照上面的原則對比一下，答案也是明朗的：
n 例7-2中，我們為派生類重載了一個函數版本：void fun(double d) 其實，這只是一個障眼法。我們具體來分析一下，基類共有幾個函數，派生類共有幾個函數：
類型
基類
派生類
Vtable部分
void fun(int i)
指向基類版的虛函數void fun(int i)
靜態部分
void fun(double d)
我們再來分析一下以下三句代碼
Base *pb = new Derive();
pb->fun(1);//Base::fun(int i)
pb->fun((double)0.01);//Base::fun(int i)
這第一句是關鍵，基類指針指向派生類的對象，我們知道這是多態調用；接下來第二句，運行時基類指針根據運行時對象的類型，發現是派生類對象，所以首先到派生類的vtable中去查找派生類的虛函數版本，發現派生類沒有覆蓋基類的虛函數，派生類的vtable只是作了一個指向基類虛函數地址的一個指向，所以理所當然地去調用基類版本的虛函數。最后一句，程序運行仍然埋頭去找派生類的vtable，發現根本沒有這個版本的虛函數，只好回頭調用自己的僅有一個虛函數。
這里還值得一提的是：如果此時基類有多個虛函數，此時程序編繹時會提示”調用不明確”。示例如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include <iostream> using namespace std; class Base{public: virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; } virtual void fun(char c){ cout <<"Base::fun(char c)"<< endl; }}; class Derive : public Base{public: void fun(double d){ cout <<"Derive::fun(double d)"<< endl; } }; int main(){ Base *pb = new Derive(); pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function delete pb; return 0;} |
好了，我們再來分析一下例8-2。
n 例8-2中，我們也為派生類重載了一個函數版本：void fun(double d) ，同時覆蓋了基類的虛函數，我們再來具體來分析一下，基類共有幾個函數，派生類共有幾個函數：
類型
基類
派生類
Vtable部分
void fun(int i)
void fun(int i)
靜態部分
void fun(double d)
從表中我們可以看到，派生類的vtable中函數指針指向的是自己的重寫的虛函數地址。
我們再來分析一下以下三句代碼
Base *pb = new Derive();
pb->fun(1);//Derive::fun(int i)
pb->fun((double)0.01);//Derive::fun(int i)
第一句不必多說了，第二句，理所當然調用派生類的虛函數版本，第三句，嘿，感覺又怪怪的，其實呀，C++程序很笨的了，在運行時，埋頭闖進派生類的vtable表中，只眼一看，靠，競然沒有想要的版本，真是想不通，基類指針為什么不四處轉轉再找找呢?呵呵，原來是眼力有限，基類年紀這么老了，想必肯定是老花了，它那雙眼睛看得到的僅是自己的非Vtable部分(即靜態部分)和自己要管理的Vtable部分，派生類的void fun(double d)那么遠，看不到呀!再說了，派生類什么都要管，難道派生類沒有自己的一點權力嗎?哎，不吵了，各自管自己的吧^_^
唉!你是不是要嘆氣了，基類指針能進行多態調用，但是始終不能進行派生類的重載調用啊(參考例6)~~~
再來看看例9，
本例的效果同例6，異曲同工。想必你理解了上面的這些例子后，這個也是小Kiss了。
小結：
重載overload是根據函數的參數列表來選擇要調用的函數版本，而多態是根據運行時對象的實際類型來選擇要調用的虛virtual函數版本，多態的實現是通過派生類對基類的虛virtual函數進行覆蓋override來實現的，若派生類沒有對基類的虛virtual函數進行覆蓋override的話，則派生類會自動繼承基類的虛virtual函數版本，此時無論基類指針指向的對象是基類型還是派生類型，都會調用基類版本的虛virtual函數；如果派生類對基類的虛virtual函數進行覆蓋override的話，則會在運行時根據對象的實際類型來選擇要調用的虛virtual函數版本，例如基類指針指向的對象類型為派生類型，則會調用派生類的虛virtual函數版本，從而實現多態。
使用多態的本意是要我們在基類中聲明函數為virtual，并且是要在派生類中覆蓋override基類的虛virtual函數版本，注意，此時的函數原型與基類保持一致，即同名同參數類型；如果你在派生類中新添加函數版本，你不能通過基類指針動態調用派生類的新的函數版本，這個新的函數版本只作為派生類的一個重載版本。還是同一句話，重載只有在當前類中有效，不管你是在基類重載的，還是在派生類中重載的，兩者互不牽連。如果明白這一點的話，在例6、例9中，我們也會對其的輸出結果順利地理解。
重載是靜態聯編的，多態是動態聯編的。進一步解釋，重載與指針實際指向的對象類型無關，多態與指針實際指向的對象類型相關。若基類的指針調用派生類的重載版本，C++編繹認為是非法的，C++編繹器只認為基類指針只能調用基類的重載版本，重載只在當前類的名字空間作用域內有效，繼承會失去重載的特性，當然，若此時的基類指針調用的是一個虛virtual函數，那么它還會進行動態選擇基類的虛virtual函數版本還是派生類的虛virtual函數版本來進行具體的操作，這是通過基類指針實際指向的對象類型來做決定的，所以說重載與指針實際指向的對象類型無關，多態與指針實際指向的對象類型相關。
最后闡明一點，虛virtual函數同樣可以進行重載，但是重載只能是在當前自己名字空間作用域內有效
到底創建了幾個String對象？
我們首先來看一段代碼：
Java代碼
String str=new String("abc");
緊接著這段代碼之后的往往是這個問題，那就是這行代碼究竟創建了幾個String對象呢？相信大家對這道題并不陌生，答案也是眾所周知的，2個。接下來我們就從這道題展開，一起回顧一下與創建String對象相關的一些JAVA知識。
我們可以把上面這行代碼分成String str、=、"abc"和new String()四部分來看待。String str只是定義了一個名為str的String類型的變量，因此它并沒有創建對象；=是對變量str進行初始化，將某個對象的引用（或者叫句柄）賦值給它，顯然也沒有創建對象；現在只剩下new String("abc")了。那么，new String("abc")為什么又能被看成"abc"和new String()呢？我們來看一下被我們調用了的String的構造器：
Java代碼
public String(String original) {
//other code ...
}
大家都知道，我們常用的創建一個類的實例（對象）的方法有以下兩種：
使用new創建對象。
調用Class類的newInstance方法，利用反射機制創建對象。
我們正是使用new調用了String類的上面那個構造器方法創建了一個對象，并將它的引用賦值給了str變量。同時我們注意到，被調用的構造器方法接受的參數也是一個String對象，這個對象正是"abc"。由此我們又要引入另外一種創建String對象的方式的討論——引號內包含文本。
這種方式是String特有的，并且它與new的方式存在很大區別。
Java代碼
String str="abc";
毫無疑問，這行代碼創建了一個String對象。
Java代碼
String a="abc";
String b="abc";
那這里呢？答案還是一個。
Java代碼
String a="ab"+"cd";
再看看這里呢？答案仍是一個。有點奇怪嗎？說到這里，我們就需要引入對字符串池相關知識的回顧了。
在JAVA虛擬機（JVM）中存在著一個字符串池，其中保存著很多String對象，并且可以被共享使用，因此它提高了效率。由于String類是final的，它的值一經創建就不可改變，因此我們不用擔心String對象共享而帶來程序的混亂。字符串池由String類維護，我們可以調用intern()方法來訪問字符串池。
我們再回頭看看String a="abc";，這行代碼被執行的時候，JAVA虛擬機首先在字符串池中查找是否已經存在了值為"abc"的這么一個對象，它的判斷依據是String類equals(Object obj)方法的返回值。如果有，則不再創建新的對象，直接返回已存在對象的引用；如果沒有，則先創建這個對象，然后把它加入到字符串池中，再將它的引用返回。因此，我們不難理解前面三個例子中頭兩個例子為什么是這個答案了。
對于第三個例子：
Java代碼
String a="ab"+"cd";
由于常量的值在編譯的時候就被確定了。在這里，"ab"和"cd"都是常量，因此變量a的值在編譯時就可以確定。這行代碼編譯后的效果等同于：
Java代碼
String a="abcd";
因此這里只創建了一個對象"abcd"，并且它被保存在字符串池里了。
現在問題又來了，是不是所有經過“+”連接后得到的字符串都會被添加到字符串池中呢？我們都知道“==”可以用來比較兩個變量，它有以下兩種情況：
如果比較的是兩個基本類型（char，byte，short，int，long，float，double，boolean），則是判斷它們的值是否相等。
如果表較的是兩個對象變量，則是判斷它們的引用是否指向同一個對象。
下面我們就用“==”來做幾個測試。為了便于說明，我們把指向字符串池中已經存在的對象也視為該對象被加入了字符串池：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
public class StringTest { public static void main(String[] args) { String a = "ab";// 創建了一個對象，并加入字符串池中 System.out.println("String a = \"ab\";"); String b = "cd";// 創建了一個對象，并加入字符串池中 System.out.println("String b = \"cd\";"); String c = "abcd";// 創建了一個對象，并加入字符串池中 String d = "ab" + "cd"; // 如果d和c指向了同一個對象，則說明d也被加入了字符串池 if (d == c) { System.out.println("\"ab\"+\"cd\" 創建的對象 \"加入了\" 字符串池中"); } // 如果d和c沒有指向了同一個對象，則說明d沒有被加入字符串池 else { System.out.println("\"ab\"+\"cd\" 創建的對象 \"沒加入\" 字符串池中"); } String e = a + "cd"; // 如果e和c指向了同一個對象，則說明e也被加入了字符串池 if (e == c) { System.out.println(" a +\"cd\" 創建的對象 \"加入了\" 字符串池中"); } // 如果e和c沒有指向了同一個對象，則說明e沒有被加入字符串池 else { System.out.println(" a +\"cd\" 創建的對象 \"沒加入\" 字符串池中"); } String f = "ab" + b; // 如果f和c指向了同一個對象，則說明f也被加入了字符串池 if (f == c) { System.out.println("\"ab\"+ b 創建的對象 \"加入了\" 字符串池中"); } // 如果f和c沒有指向了同一個對象，則說明f沒有被加入字符串池 else { System.out.println("\"ab\"+ b 創建的對象 \"沒加入\" 字符串池中"); } String g = a + b; // 如果g和c指向了同一個對象，則說明g也被加入了字符串池 if (g == c) { System.out.println(" a + b 創建的對象 \"加入了\" 字符串池中"); } // 如果g和c沒有指向了同一個對象，則說明g沒有被加入字符串池 else { System.out.println(" a + b 創建的對象 \"沒加入\" 字符串池中"); } } } |
運行結果如下：
String a = "ab";
String b = "cd";
"ab"+"cd" 創建的對象 "加入了" 字符串池中
a +"cd" 創建的對象 "沒加入" 字符串池中
"ab"+ b 創建的對象 "沒加入" 字符串池中
a + b 創建的對象 "沒加入" 字符串池中
從上面的結果中我們不難看出，只有使用引號包含文本的方式創建的String對象之間使用“+”連接產生的新對象才會被加入字符串池中。對于所有包含new方式新建對象（包括null）的“+”連接表達式，它所產生的新對象都不會被加入字符串池中，對此我們不再贅述。
但是有一種情況需要引起我們的注意。請看下面的代碼：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public class StringStaticTest { // 常量A public static final String A = "ab"; // 常量B public static final String B = "cd"; public static void main(String[] args) { // 將兩個常量用+連接對s進行初始化 String s = A + B; String t = "abcd"; if (s == t) { System.out.println("s等于t，它們是同一個對象"); } else { System.out.println("s不等于t，它們不是同一個對象"); } } } |
這段代碼的運行結果如下：
s等于t，它們是同一個對象
這又是為什么呢？原因是這樣的，對于常量來講，它的值是固定的，因此在編譯期就能被確定了，而變量的值只有到運行時才能被確定，因為這個變量可以被不同的方法調用，從而可能引起值的改變。在上面的例子中，A和B都是常量，值是固定的，因此s的值也是固定的，它在類被編譯時就已經確定了。也就是說：
Java代碼
String s=A+B;
等同于：
Java代碼
String s="ab"+"cd";
我對上面的例子稍加改變看看會出現什么情況：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public class StringStaticTest { // 常量A public static final String A; // 常量B public static final String B; static { A = "ab"; B = "cd"; } public static void main(String[] args) { // 將兩個常量用+連接對s進行初始化 String s = A + B; String t = "abcd"; if (s == t) { System.out.println("s等于t，它們是同一個對象"); } else { System.out.println("s不等于t，它們不是同一個對象"); } } } |
它的運行結果是這樣：
s不等于t，它們不是同一個對象
只是做了一點改動，結果就和剛剛的例子恰好相反。我們再來分析一下。A和B雖然被定義為常量（只能被賦值一次），但是它們都沒有馬上被賦值。在運算出s的值之前，他們何時被賦值，以及被賦予什么樣的值，都是個變數。因此A和B在被賦值之前，性質類似于一個變量。那么s就不能在編譯期被確定，而只能在運行時被創建了。
由于字符串池中對象的共享能夠帶來效率的提高，因此我們提倡大家用引號包含文本的方式來創建String對象，實際上這也是我們在編程中常采用的。
接下來我們再來看看intern()方法，它的定義如下：
Java代碼
public native String intern();
這是一個本地方法。在調用這個方法時，JAVA虛擬機首先檢查字符串池中是否已經存在與該對象值相等對象存在，如果有則返回字符串池中對象的引用；如果沒有，則先在字符串池中創建一個相同值的String對象，然后再將它的引用返回。
我們來看這段代碼：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class StringInternTest { public static void main(String[] args) { // 使用char數組來初始化a，避免在a被創建之前字符串池中已經存在了值為"abcd"的對象 String a = new String(new char[] { 'a', 'b', 'c', 'd' }); String b = a.intern(); if (b == a) { System.out.println("b被加入了字符串池中，沒有新建對象"); } else { System.out.println("b沒被加入字符串池中，新建了對象"); } } } |
運行結果：
b沒被加入字符串池中，新建了對象
如果String類的intern()方法在沒有找到相同值的對象時，是把當前對象加入字符串池中，然后返回它的引用的話，那么b和a指向的就是同一個對象；否則b指向的對象就是JAVA虛擬機在字符串池中新建的，只是它的值與a相同罷了。上面這段代碼的運行結果恰恰印證了這一點。
最后我們再來說說String對象在JAVA虛擬機（JVM）中的存儲，以及字符串池與堆（heap）和棧（stack）的關系。我們首先回顧一下堆和棧的區別：
棧（stack）：主要保存基本類型（或者叫內置類型）（char、byte、short、int、long、float、double、boolean）和對象的引用，數據可以共享，速度僅次于寄存器（register），快于堆。
堆（heap）：用于存儲對象。
我們查看String類的源碼就會發現，它有一個value屬性，保存著String對象的值，類型是char[]，這也正說明了字符串就是字符的序列。
當執行String a="abc";時，JAVA虛擬機會在棧中創建三個char型的值'a'、'b'和'c'，然后在堆中創建一個String對象，它的值（value）是剛才在棧中創建的三個char型值組成的數組{'a','b','c'}，最后這個新創建的String對象會被添加到字符串池中。如果我們接著執行String b=new String("abc");代碼，由于"abc"已經被創建并保存于字符串池中，因此JAVA虛擬機只會在堆中新創建一個String對象，但是它的值（value）是共享前一行代碼執行時在棧中創建的三個char型值值'a'、'b'和'c'。
說到這里，我們對于篇首提出的String str=new String("abc")為什么是創建了兩個對象這個問題就已經相當明了了。
