什么是多態(tài)？它的實現(xiàn)機制是什么呢？重載和重寫的區(qū)別在那里？這就是這一次我們要回顧的四個十分重要的概念：繼承、多態(tài)、重載和重寫。

繼承(inheritance)

簡單的說，繼承就是在一個現(xiàn)有類型的基礎(chǔ)上，通過增加新的方法或者重定義已有方法（下面會講到，這種方式叫重寫）的方式，產(chǎn)生一個新的類型。繼承是面向?qū)ο蟮娜齻€基本特征--封裝、繼承、多態(tài)的其中之一，我們在使用JAVA時編寫的每一個類都是在繼承，因為在JAVA語言中，java.lang.Object類是所有類最根本的基類（或者叫父類、超類），如果我們新定義的一個類沒有明確地指定繼承自哪個基類，那么JAVA就會默認(rèn)為它是繼承自O(shè)bject類的。

我們可以把JAVA中的類分為以下三種：

類：使用class定義且不含有抽象方法的類。
抽象類：使用abstract class定義的類，它可以含有，也可以不含有抽象方法。
接口：使用interface定義的類。

在這三種類型之間存在下面的繼承規(guī)律：

類可以繼承（extends）類，可以繼承（extends）抽象類，可以繼承（implements）接口。
抽象類可以繼承（extends）類，可以繼承（extends）抽象類，可以繼承（implements）接口。
接口只能繼承（extends）接口。

請注意上面三條規(guī)律中每種繼承情況下使用的不同的關(guān)鍵字extends和implements，它們是不可以隨意替換的。大家知道，一個普通類繼承一個接口后，必須實現(xiàn)這個接口中定義的所有方法，否則就只能被定義為抽象類。我在這里之所以沒有對implements關(guān)鍵字使用“實現(xiàn)”這種說法是因為從概念上來說它也是表示一種繼承關(guān)系，而且對于抽象類implements接口的情況下，它并不是一定要實現(xiàn)這個接口定義的任何方法，因此使用繼承的說法更為合理一些。

以上三條規(guī)律同時遵守下面這些約束：

類和抽象類都只能最多繼承一個類，或者最多繼承一個抽象類，并且這兩種情況是互斥的，也就是說它們要么繼承一個類，要么繼承一個抽象類。
類、抽象類和接口在繼承接口時，不受數(shù)量的約束，理論上可以繼承無限多個接口。當(dāng)然，對于類來說，它必須實現(xiàn)它所繼承的所有接口中定義的全部方法。
抽象類繼承抽象類，或者實現(xiàn)接口時，可以部分、全部或者完全不實現(xiàn)父類抽象類的抽象（abstract）方法，或者父類接口中定義的接口。
類繼承抽象類，或者實現(xiàn)接口時，必須全部實現(xiàn)父類抽象類的全部抽象（abstract）方法，或者父類接口中定義的全部接口。

繼承給我們的編程帶來的好處就是對原有類的復(fù)用（重用）。就像模塊的復(fù)用一樣，類的復(fù)用可以提高我們的開發(fā)效率，實際上，模塊的復(fù)用是大量類的復(fù)用疊加后的效果。除了繼承之外，我們還可以使用組合的方式來復(fù)用類。所謂組合就是把原有類定義為新類的一個屬性，通過在新類中調(diào)用原有類的方法來實現(xiàn)復(fù)用。如果新定義的類型與原有類型之間不存在被包含的關(guān)系，也就是說，從抽象概念上來講，新定義類型所代表的事物并不是原有類型所代表事物的一種，比如黃種人是人類的一種，它們之間存在包含與被包含的關(guān)系，那么這時組合就是實現(xiàn)復(fù)用更好的選擇。下面這個例子就是組合方式的一個簡單示例：

public class Sub { 
  private Parent p = new Parent(); 
 
  public void doSomething() { 
    // 復(fù)用Parent類的方法 
    p.method(); 
    // other code 
  } 
} 
 
class Parent { 
  public void method() { 
    // do something here 
  } 
} 

 當(dāng)然，為了使代碼更加有效，我們也可以在需要使用到原有類型（比如Parent p）時，才對它進(jìn)行初始化。

使用繼承和組合復(fù)用原有的類，都是一種增量式的開發(fā)模式，這種方式帶來的好處是不需要修改原有的代碼，因此不會給原有代碼帶來新的BUG，也不用因為對原有代碼的修改而重新進(jìn)行測試，這對我們的開發(fā)顯然是有益的。因此，如果我們是在維護(hù)或者改造一個原有的系統(tǒng)或模塊，尤其是對它們的了解不是很透徹的時候，就可以選擇增量開發(fā)的模式，這不僅可以大大提高我們的開發(fā)效率，也可以規(guī)避由于對原有代碼的修改而帶來的風(fēng)險。

多態(tài)(Polymorphism)

多態(tài)是又一個重要的基本概念，上面說到了，它是面向?qū)ο蟮娜齻€基本特征之一。究竟什么是多態(tài)呢？我們先看看下面的例子，來幫助理解：

//汽車接口 
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()); 
  } 
} 

運行結(jié)果：

車型：BMW  單價：300000
車型：CheryQQ  單價：20000
總收入：320000

繼承是多態(tài)得以實現(xiàn)的基礎(chǔ)。從字面上理解，多態(tài)就是一種類型（都是Car類型）表現(xiàn)出多種狀態(tài)（寶馬汽車的名稱是BMW，售價是300000；奇瑞汽車的名稱是CheryQQ，售價是2000）。將一個方法調(diào)用同這個方法所屬的主體（也就是對象或類）關(guān)聯(lián)起來叫做綁定，分前期綁定和后期綁定兩種。下面解釋一下它們的定義：

前期綁定：在程序運行之前進(jìn)行綁定，由編譯器和連接程序?qū)崿F(xiàn)，又叫做靜態(tài)綁定。比如static方法和final方法，注意，這里也包括private方法，因為它是隱式final的。
后期綁定：在運行時根據(jù)對象的類型進(jìn)行綁定，由方法調(diào)用機制實現(xiàn)，因此又叫做動態(tài)綁定，或者運行時綁定。除了前期綁定外的所有方法都屬于后期綁定。

多態(tài)就是在后期綁定這種機制上實現(xiàn)的。多態(tài)給我們帶來的好處是消除了類之間的耦合關(guān)系，使程序更容易擴展。比如在上例中，新增加一種類型汽車的銷售，只需要讓新定義的類繼承Car類并實現(xiàn)它的所有方法，而無需對原有代碼做任何修改，CarShop類的sellCar(Car car)方法就可以處理新的車型了。新增代碼如下：

// 桑塔納汽車 
class Santana implements Car { 
  public String getName() { 
    return "Santana"; 
  } 
 
  public int getPrice() { 
    return 80000; 
  } 
} 

重載(overloading)和重寫(overriding)

重載和重寫都是針對方法的概念，在弄清楚這兩個概念之前，我們先來了解一下什么叫方法的型構(gòu)（英文名是signature，有的譯作“簽名”，雖然它被使用的較為廣泛，但是這個翻譯不準(zhǔn)確的）。型構(gòu)就是指方法的組成結(jié)構(gòu)，具體包括方法的名稱和參數(shù)，涵蓋參數(shù)的數(shù)量、類型以及出現(xiàn)的順序，但是不包括方法的返回值類型，訪問權(quán)限修飾符，以及abstract、static、final等修飾符。比如下面兩個就是具有相同型構(gòu)的方法：

public void method(int i, String s) { 
  // do something 
} 
 
public String method(int i, String s) { 
  // do something 
} 

而這兩個就是具有不同型構(gòu)的方法：

public void method(int i, String s) { 
  // do something 
} 
 
public void method(String s, int i) { 
  // do something 
} 

了解完型構(gòu)的概念后我們再來看看重載和重寫，請看它們的定義：

重寫，英文名是overriding，是指在繼承情況下，子類中定義了與其基類中方法具有相同型構(gòu)的新方法，就叫做子類把基類的方法重寫了。這是實現(xiàn)多態(tài)必須的步驟。
重載，英文名是overloading，是指在同一個類中定義了一個以上具有相同名稱，但是型構(gòu)不同的方法。在同一個類中，是不允許定義多于一個的具有相同型構(gòu)的方法的。

我們來考慮一個有趣的問題：構(gòu)造器可以被重載嗎？答案當(dāng)然是可以的，我們在實際的編程中也經(jīng)常這么做。實際上構(gòu)造器也是一個方法，構(gòu)造器名就是方法名，構(gòu)造器參數(shù)就是方法參數(shù)，而它的返回值就是新創(chuàng)建的類的實例。但是構(gòu)造器卻不可以被子類重寫，因為子類無法定義與基類具有相同型構(gòu)的構(gòu)造器。

重載、覆蓋、多態(tài)與函數(shù)隱藏

經(jīng)常看到C++的一些初學(xué)者對于重載、覆蓋、多態(tài)與函數(shù)隱藏的模糊理解。在這里寫一點自己的見解，希望能夠C++初學(xué)者解惑。

要弄清楚重載、覆蓋、多態(tài)與函數(shù)隱藏之間的復(fù)雜且微妙關(guān)系之前，我們首先要來回顧一下重載覆蓋等基本概念。

首先，我們來看一個非常簡單的例子，理解一下什么叫函數(shù)隱藏hide。

#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;
}

/*在不同的非命名空間作用域里的函數(shù)不構(gòu)成重載,子類和父類是不同的兩個作用域。
在本例中,兩個函數(shù)在不同作用域中,故不夠成重載,除非這個作用域是命名空間作用域。*/
在這個例子中，函數(shù)不是重載overload，也不是覆蓋override，而是隱藏hide。

接下來的5個例子具體說明一下什么叫隱藏

例1

#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();//正確，派生類沒有與基類同名函數(shù)聲明，則基類中的所有同名重載函數(shù)都會作為候選函數(shù)。
     d.fun(1);//正確，派生類沒有與基類同名函數(shù)聲明，則基類中的所有同名重載函數(shù)都會作為候選函數(shù)。
     return 0;
}

例2

#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:
     //新的函數(shù)版本,基類所有的重載版本都被屏蔽,在這里,我們稱之為函數(shù)隱藏hide
  //派生類中有基類的同名函數(shù)的聲明，則基類中的同名函數(shù)不會作為候選函數(shù)，即使基類有不同的參數(shù)表的多個版本的重載函數(shù)。
     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

#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基類的其中一個函數(shù)版本,同樣基類所有的重載版本都被隱藏hide
  //派生類中有基類的同名函數(shù)的聲明，則基類中的同名函數(shù)不會作為候選函數(shù)，即使基類有不同的參數(shù)表的多個版本的重載函數(shù)。
     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

#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;
}
/*
輸出結(jié)果
Derive::fun()
Base::fun(int i)
Press any key to continue
*/

例5

#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;
}
/*
輸出結(jié)果
Base::fun()
Base::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/ 

好了，我們先來一個小小的總結(jié)重載與覆蓋兩者之間的特征

重載overload的特征：

n          相同的范圍(在同一個類中)；
n          函數(shù)名相同參數(shù)不同；
n          virtual 關(guān)鍵字可有可無。

覆蓋override是指派生類函數(shù)覆蓋基類函數(shù)，覆蓋的特征是：

n          不同的范圍(分別位于派生類與基類)；
n          函數(shù)名和參數(shù)都相同；
n          基類函數(shù)必須有virtual 關(guān)鍵字。(若沒有virtual 關(guān)鍵字則稱之為隱藏hide)

如果基類有某個函數(shù)的多個重載(overload)版本，而你在派生類中重寫(override)了基類中的一個或多個函數(shù)版本，或是在派生類中重新添加了新的函數(shù)版本(函數(shù)名相同，參數(shù)不同)，則所有基類的重載版本都被屏蔽，在這里我們稱之為隱藏hide。所以，在一般情況下，你想在派生類中使用新的函數(shù)版本又想使用基類的函數(shù)版本時，你應(yīng)該在派生類中重寫基類中的所有重載版本。你若是不想重寫基類的重載的函數(shù)版本，則你應(yīng)該使用例4或例5方式，顯式聲明基類名字空間作用域。
事實上，C++編譯器認(rèn)為，相同函數(shù)名不同參數(shù)的函數(shù)之間根本沒有什么關(guān)系，它們根本就是兩個毫不相關(guān)的函數(shù)。只是C++語言為了模擬現(xiàn)實世界，為了讓程序員更直觀的思維處理現(xiàn)實世界中的問題，才引入了重載和覆蓋的概念。重載是在相同名字空間作用域下，而覆蓋則是在不同的名字空間作用域下，比如基類和派生類即為兩個不同的名字空間作用域。在繼承過程中，若發(fā)生派生類與基類函數(shù)同名問題時，便會發(fā)生基類函數(shù)的隱藏。當(dāng)然，這里討論的情況是基類函數(shù)前面沒有virtual 關(guān)鍵字。在有virtual 關(guān)鍵字關(guān)鍵字時的情形我們另做討論。
繼承類重寫了基類的某一函數(shù)版本，以產(chǎn)生自己功能的接口。此時C++編繹器認(rèn)為，你現(xiàn)在既然要使用派生類的自己重新改寫的接口，那我基類的接口就不提供給你了(當(dāng)然你可以用顯式聲明名字空間作用域的方法，見[C++基礎(chǔ)]重載、覆蓋、多態(tài)與函數(shù)隱藏(1))。而不會理會你基類的接口是有重載特性的。若是你要在派生類里繼續(xù)保持重載的特性，那你就自己再給出接口重載的特性吧。所以在派生類里，只要函數(shù)名一樣，基類的函數(shù)版本就會被無情地屏蔽。在編繹器中，屏蔽是通過名字空間作用域?qū)崿F(xiàn)的。

所以，在派生類中要保持基類的函數(shù)重載版本，就應(yīng)該重寫所有基類的重載版本。重載只在當(dāng)前類中有效，繼承會失去函數(shù)重載的特性。也就是說，要把基類的重載函數(shù)放在繼承的派生類里，就必須重寫。

這里“隱藏”是指派生類的函數(shù)屏蔽了與其同名的基類函數(shù)，具體規(guī)則我們也來做一小結(jié)：

n          如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。此時，若基類無virtual關(guān)鍵字，基類的函數(shù)將被隱藏。(注意別與重載混淆，雖然函數(shù)名相同參數(shù)不同應(yīng)稱之為重載，但這里不能理解為重載，因為派生類和基類不在同一名字空間作用域內(nèi)。這里理解為隱藏)
n          如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。此時，若基類有virtual關(guān)鍵字，基類的函數(shù)將被隱式繼承到派生類的vtable中。此時派生類vtable中的函數(shù)指向基類版本的函數(shù)地址。同時這個新的函數(shù)版本添加到派生類中，作為派生類的重載版本。但在基類指針實現(xiàn)多態(tài)調(diào)用函數(shù)方法時，這個新的派生類函數(shù)版本將會被隱藏。
n          如果派生類的函數(shù)與基類的函數(shù)同名，并且參數(shù)也相同，但是基類函數(shù)沒有virtual關(guān)鍵字。此時，基類的函數(shù)被隱藏。(注意別與覆蓋混淆，這里理解為隱藏)。
n          如果派生類的函數(shù)與基類的函數(shù)同名，并且參數(shù)也相同，但是基類函數(shù)有virtual關(guān)鍵字。此時，基類的函數(shù)不會被“隱藏”。(在這里，你要理解為覆蓋哦^_^)。

插曲：基類函數(shù)前沒有virtual關(guān)鍵字時，我們要重寫更為順口些，在有virtual關(guān)鍵字時，我們叫覆蓋更為合理些，戒此，我也希望大家能夠更好的理解C++中一些微妙的東西。費話少說，我們舉例說明吧。

例6

#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函數(shù)不能進(jìn)行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;
}
/*

輸出結(jié)果

 
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

#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

#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

#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

#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

#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中，派生類沒有覆蓋基類的虛函數(shù)，此時派生類的vtable中的函數(shù)指針指向的地址就是基類的虛函數(shù)地址。
n          例8-1中，派生類覆蓋了基類的虛函數(shù)，此時派生類的vtable中的函數(shù)指針指向的地址就是派生類自己的重寫的虛函數(shù)地址。
在例7-2和8-2看起來有點怪怪，其實，你按照上面的原則對比一下，答案也是明朗的：
n          例7-2中，我們?yōu)榕缮愔剌d了一個函數(shù)版本：void fun(double d)  其實，這只是一個障眼法。我們具體來分析一下，基類共有幾個函數(shù)，派生類共有幾個函數(shù)：
類型
 基類
 派生類
 
Vtable部分
 void fun(int i)
 指向基類版的虛函數(shù)void fun(int i)
 
靜態(tà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)
 
這第一句是關(guān)鍵，基類指針指向派生類的對象，我們知道這是多態(tài)調(diào)用；接下來第二句，運行時基類指針根據(jù)運行時對象的類型，發(fā)現(xiàn)是派生類對象，所以首先到派生類的vtable中去查找派生類的虛函數(shù)版本，發(fā)現(xiàn)派生類沒有覆蓋基類的虛函數(shù)，派生類的vtable只是作了一個指向基類虛函數(shù)地址的一個指向，所以理所當(dāng)然地去調(diào)用基類版本的虛函數(shù)。最后一句，程序運行仍然埋頭去找派生類的vtable，發(fā)現(xiàn)根本沒有這個版本的虛函數(shù)，只好回頭調(diào)用自己的僅有一個虛函數(shù)。
 
這里還值得一提的是：如果此時基類有多個虛函數(shù)，此時程序編繹時會提示”調(diào)用不明確”。示例如下

#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中，我們也為派生類重載了一個函數(shù)版本：void fun(double d)  ，同時覆蓋了基類的虛函數(shù)，我們再來具體來分析一下，基類共有幾個函數(shù)，派生類共有幾個函數(shù)：

類型
 基類
 派生類
 
Vtable部分
 void fun(int i)
 void fun(int i)
 
靜態(tài)部分
 
 void fun(double d)
 從表中我們可以看到，派生類的vtable中函數(shù)指針指向的是自己的重寫的虛函數(shù)地址。
 
我們再來分析一下以下三句代碼
 
Base *pb = new Derive();
pb->fun(1);//Derive::fun(int i)
pb->fun((double)0.01);//Derive::fun(int i)
 
第一句不必多說了，第二句，理所當(dāng)然調(diào)用派生類的虛函數(shù)版本，第三句，嘿，感覺又怪怪的，其實呀，C++程序很笨的了，在運行時，埋頭闖進(jìn)派生類的vtable表中，只眼一看，靠，競?cè)粵]有想要的版本，真是想不通，基類指針為什么不四處轉(zhuǎn)轉(zhuǎn)再找找呢?呵呵，原來是眼力有限，基類年紀(jì)這么老了，想必肯定是老花了，它那雙眼睛看得到的僅是自己的非Vtable部分(即靜態(tài)部分)和自己要管理的Vtable部分，派生類的void fun(double d)那么遠(yuǎn)，看不到呀!再說了，派生類什么都要管，難道派生類沒有自己的一點權(quán)力嗎?哎，不吵了，各自管自己的吧^_^
 
唉!你是不是要嘆氣了，基類指針能進(jìn)行多態(tài)調(diào)用，但是始終不能進(jìn)行派生類的重載調(diào)用啊(參考例6)~~~
 
再來看看例9，
本例的效果同例6，異曲同工。想必你理解了上面的這些例子后，這個也是小Kiss了。
小結(jié)：
 
        重載overload是根據(jù)函數(shù)的參數(shù)列表來選擇要調(diào)用的函數(shù)版本，而多態(tài)是根據(jù)運行時對象的實際類型來選擇要調(diào)用的虛virtual函數(shù)版本，多態(tài)的實現(xiàn)是通過派生類對基類的虛virtual函數(shù)進(jìn)行覆蓋override來實現(xiàn)的，若派生類沒有對基類的虛virtual函數(shù)進(jìn)行覆蓋override的話，則派生類會自動繼承基類的虛virtual函數(shù)版本，此時無論基類指針指向的對象是基類型還是派生類型，都會調(diào)用基類版本的虛virtual函數(shù)；如果派生類對基類的虛virtual函數(shù)進(jìn)行覆蓋override的話，則會在運行時根據(jù)對象的實際類型來選擇要調(diào)用的虛virtual函數(shù)版本，例如基類指針指向的對象類型為派生類型，則會調(diào)用派生類的虛virtual函數(shù)版本，從而實現(xiàn)多態(tài)。
 
        使用多態(tài)的本意是要我們在基類中聲明函數(shù)為virtual，并且是要在派生類中覆蓋override基類的虛virtual函數(shù)版本，注意，此時的函數(shù)原型與基類保持一致，即同名同參數(shù)類型；如果你在派生類中新添加函數(shù)版本，你不能通過基類指針動態(tài)調(diào)用派生類的新的函數(shù)版本，這個新的函數(shù)版本只作為派生類的一個重載版本。還是同一句話，重載只有在當(dāng)前類中有效，不管你是在基類重載的，還是在派生類中重載的，兩者互不牽連。如果明白這一點的話，在例6、例9中，我們也會對其的輸出結(jié)果順利地理解。
 
        重載是靜態(tài)聯(lián)編的，多態(tài)是動態(tài)聯(lián)編的。進(jìn)一步解釋，重載與指針實際指向的對象類型無關(guān)，多態(tài)與指針實際指向的對象類型相關(guān)。若基類的指針調(diào)用派生類的重載版本，C++編繹認(rèn)為是非法的，C++編繹器只認(rèn)為基類指針只能調(diào)用基類的重載版本，重載只在當(dāng)前類的名字空間作用域內(nèi)有效，繼承會失去重載的特性，當(dāng)然，若此時的基類指針調(diào)用的是一個虛virtual函數(shù)，那么它還會進(jìn)行動態(tài)選擇基類的虛virtual函數(shù)版本還是派生類的虛virtual函數(shù)版本來進(jìn)行具體的操作，這是通過基類指針實際指向的對象類型來做決定的，所以說重載與指針實際指向的對象類型無關(guān)，多態(tài)與指針實際指向的對象類型相關(guān)。
 
    最后闡明一點，虛virtual函數(shù)同樣可以進(jìn)行重載，但是重載只能是在當(dāng)前自己名字空間作用域內(nèi)有效
 
到底創(chuàng)建了幾個String對象？
我們首先來看一段代碼：
Java代碼
String str=new String("abc"); 
緊接著這段代碼之后的往往是這個問題，那就是這行代碼究竟創(chuàng)建了幾個String對象呢？相信大家對這道題并不陌生，答案也是眾所周知的，2個。接下來我們就從這道題展開，一起回顧一下與創(chuàng)建String對象相關(guān)的一些JAVA知識。
我們可以把上面這行代碼分成String str、=、"abc"和new String()四部分來看待。String str只是定義了一個名為str的String類型的變量，因此它并沒有創(chuàng)建對象；=是對變量str進(jìn)行初始化，將某個對象的引用（或者叫句柄）賦值給它，顯然也沒有創(chuàng)建對象；現(xiàn)在只剩下new String("abc")了。那么，new String("abc")為什么又能被看成"abc"和new String()呢？我們來看一下被我們調(diào)用了的String的構(gòu)造器：
Java代碼
public String(String original) { 
    //other code ... 
} 
大家都知道，我們常用的創(chuàng)建一個類的實例（對象）的方法有以下兩種：
使用new創(chuàng)建對象。
調(diào)用Class類的newInstance方法，利用反射機制創(chuàng)建對象。
我們正是使用new調(diào)用了String類的上面那個構(gòu)造器方法創(chuàng)建了一個對象，并將它的引用賦值給了str變量。同時我們注意到，被調(diào)用的構(gòu)造器方法接受的參數(shù)也是一個String對象，這個對象正是"abc"。由此我們又要引入另外一種創(chuàng)建String對象的方式的討論——引號內(nèi)包含文本。
這種方式是String特有的，并且它與new的方式存在很大區(qū)別。
Java代碼
String str="abc"; 
毫無疑問，這行代碼創(chuàng)建了一個String對象。
Java代碼
String a="abc"; 
String b="abc"; 
那這里呢？答案還是一個。
Java代碼
String a="ab"+"cd"; 
再看看這里呢？答案仍是一個。有點奇怪嗎？說到這里，我們就需要引入對字符串池相關(guān)知識的回顧了。
在JAVA虛擬機（JVM）中存在著一個字符串池，其中保存著很多String對象，并且可以被共享使用，因此它提高了效率。由于String類是final的，它的值一經(jīng)創(chuàng)建就不可改變，因此我們不用擔(dān)心String對象共享而帶來程序的混亂。字符串池由String類維護(hù)，我們可以調(diào)用intern()方法來訪問字符串池。
我們再回頭看看String a="abc";，這行代碼被執(zhí)行的時候，JAVA虛擬機首先在字符串池中查找是否已經(jīng)存在了值為"abc"的這么一個對象，它的判斷依據(jù)是String類equals(Object obj)方法的返回值。如果有，則不再創(chuàng)建新的對象，直接返回已存在對象的引用；如果沒有，則先創(chuàng)建這個對象，然后把它加入到字符串池中，再將它的引用返回。因此，我們不難理解前面三個例子中頭兩個例子為什么是這個答案了。
對于第三個例子：
Java代碼
String a="ab"+"cd"; 
由于常量的值在編譯的時候就被確定了。在這里，"ab"和"cd"都是常量，因此變量a的值在編譯時就可以確定。這行代碼編譯后的效果等同于：
Java代碼
String a="abcd"; 
因此這里只創(chuàng)建了一個對象"abcd"，并且它被保存在字符串池里了。
現(xiàn)在問題又來了，是不是所有經(jīng)過“+”連接后得到的字符串都會被添加到字符串池中呢？我們都知道“==”可以用來比較兩個變量，它有以下兩種情況：
如果比較的是兩個基本類型（char，byte，short，int，long，float，double，boolean），則是判斷它們的值是否相等。
如果表較的是兩個對象變量，則是判斷它們的引用是否指向同一個對象。
下面我們就用“==”來做幾個測試。為了便于說明，我們把指向字符串池中已經(jīng)存在的對象也視為該對象被加入了字符串池：
Java代碼

public class StringTest { 
  public static void main(String[] args) { 
    String a = "ab";// 創(chuàng)建了一個對象，并加入字符串池中 
    System.out.println("String a = \"ab\";"); 
    String b = "cd";// 創(chuàng)建了一個對象，并加入字符串池中 
    System.out.println("String b = \"cd\";"); 
    String c = "abcd";// 創(chuàng)建了一個對象，并加入字符串池中 
 
    String d = "ab" + "cd"; 
    // 如果d和c指向了同一個對象，則說明d也被加入了字符串池 
    if (d == c) { 
      System.out.println("\"ab\"+\"cd\" 創(chuàng)建的對象 \"加入了\" 字符串池中"); 
    } 
    // 如果d和c沒有指向了同一個對象，則說明d沒有被加入字符串池 
    else { 
      System.out.println("\"ab\"+\"cd\" 創(chuàng)建的對象 \"沒加入\" 字符串池中"); 
    } 
 
    String e = a + "cd"; 
    // 如果e和c指向了同一個對象，則說明e也被加入了字符串池 
    if (e == c) { 
      System.out.println(" a +\"cd\" 創(chuàng)建的對象 \"加入了\" 字符串池中"); 
    } 
    // 如果e和c沒有指向了同一個對象，則說明e沒有被加入字符串池 
    else { 
      System.out.println(" a +\"cd\" 創(chuàng)建的對象 \"沒加入\" 字符串池中"); 
    } 
 
    String f = "ab" + b; 
    // 如果f和c指向了同一個對象，則說明f也被加入了字符串池 
    if (f == c) { 
      System.out.println("\"ab\"+ b  創(chuàng)建的對象 \"加入了\" 字符串池中"); 
    } 
    // 如果f和c沒有指向了同一個對象，則說明f沒有被加入字符串池 
    else { 
      System.out.println("\"ab\"+ b  創(chuàng)建的對象 \"沒加入\" 字符串池中"); 
    } 
 
    String g = a + b; 
    // 如果g和c指向了同一個對象，則說明g也被加入了字符串池 
    if (g == c) { 
      System.out.println(" a + b  創(chuàng)建的對象 \"加入了\" 字符串池中"); 
    } 
    // 如果g和c沒有指向了同一個對象，則說明g沒有被加入字符串池 
    else { 
      System.out.println(" a + b  創(chuàng)建的對象 \"沒加入\" 字符串池中"); 
    } 
  } 
} 

運行結(jié)果如下：
String a = "ab";
String b = "cd";
"ab"+"cd" 創(chuàng)建的對象 "加入了" 字符串池中
a  +"cd" 創(chuàng)建的對象 "沒加入" 字符串池中
"ab"+ b   創(chuàng)建的對象 "沒加入" 字符串池中
a  + b   創(chuàng)建的對象 "沒加入" 字符串池中
從上面的結(jié)果中我們不難看出，只有使用引號包含文本的方式創(chuàng)建的String對象之間使用“+”連接產(chǎn)生的新對象才會被加入字符串池中。對于所有包含new方式新建對象（包括null）的“+”連接表達(dá)式，它所產(chǎn)生的新對象都不會被加入字符串池中，對此我們不再贅述。
但是有一種情況需要引起我們的注意。請看下面的代碼：
Java代碼 

public class StringStaticTest { 
  // 常量A 
  public static final String A = "ab"; 
 
  // 常量B 
  public static final String B = "cd"; 
 
  public static void main(String[] args) { 
    // 將兩個常量用+連接對s進(jìn)行初始化 
    String s = A + B; 
    String t = "abcd"; 
    if (s == t) { 
      System.out.println("s等于t，它們是同一個對象"); 
    } else { 
      System.out.println("s不等于t，它們不是同一個對象"); 
    } 
  } 
} 

這段代碼的運行結(jié)果如下：
s等于t，它們是同一個對象
這又是為什么呢？原因是這樣的，對于常量來講，它的值是固定的，因此在編譯期就能被確定了，而變量的值只有到運行時才能被確定，因為這個變量可以被不同的方法調(diào)用，從而可能引起值的改變。在上面的例子中，A和B都是常量，值是固定的，因此s的值也是固定的，它在類被編譯時就已經(jīng)確定了。也就是說：
Java代碼
String s=A+B; 
等同于：
Java代碼
String s="ab"+"cd"; 
我對上面的例子稍加改變看看會出現(xiàn)什么情況：
Java代碼

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進(jìn)行初始化 
    String s = A + B; 
    String t = "abcd"; 
    if (s == t) { 
      System.out.println("s等于t，它們是同一個對象"); 
    } else { 
      System.out.println("s不等于t，它們不是同一個對象"); 
    } 
  } 
} 

它的運行結(jié)果是這樣：
s不等于t，它們不是同一個對象
只是做了一點改動，結(jié)果就和剛剛的例子恰好相反。我們再來分析一下。A和B雖然被定義為常量（只能被賦值一次），但是它們都沒有馬上被賦值。在運算出s的值之前，他們何時被賦值，以及被賦予什么樣的值，都是個變數(shù)。因此A和B在被賦值之前，性質(zhì)類似于一個變量。那么s就不能在編譯期被確定，而只能在運行時被創(chuàng)建了。
由于字符串池中對象的共享能夠帶來效率的提高，因此我們提倡大家用引號包含文本的方式來創(chuàng)建String對象，實際上這也是我們在編程中常采用的。
接下來我們再來看看intern()方法，它的定義如下：
Java代碼
public native String intern(); 
這是一個本地方法。在調(diào)用這個方法時，JAVA虛擬機首先檢查字符串池中是否已經(jīng)存在與該對象值相等對象存在，如果有則返回字符串池中對象的引用；如果沒有，則先在字符串池中創(chuàng)建一個相同值的String對象，然后再將它的引用返回。
我們來看這段代碼：
Java代碼

public class StringInternTest { 
  public static void main(String[] args) { 
    // 使用char數(shù)組來初始化a，避免在a被創(chuàng)建之前字符串池中已經(jīng)存在了值為"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沒被加入字符串池中，新建了對象"); 
    } 
  } 
} 

運行結(jié)果：
b沒被加入字符串池中，新建了對象
如果String類的intern()方法在沒有找到相同值的對象時，是把當(dāng)前對象加入字符串池中，然后返回它的引用的話，那么b和a指向的就是同一個對象；否則b指向的對象就是JAVA虛擬機在字符串池中新建的，只是它的值與a相同罷了。上面這段代碼的運行結(jié)果恰恰印證了這一點。
最后我們再來說說String對象在JAVA虛擬機（JVM）中的存儲，以及字符串池與堆（heap）和棧（stack）的關(guān)系。我們首先回顧一下堆和棧的區(qū)別：
棧（stack）：主要保存基本類型（或者叫內(nèi)置類型）（char、byte、short、int、long、float、double、boolean）和對象的引用，數(shù)據(jù)可以共享，速度僅次于寄存器（register），快于堆。
堆（heap）：用于存儲對象。
我們查看String類的源碼就會發(fā)現(xiàn)，它有一個value屬性，保存著String對象的值，類型是char[]，這也正說明了字符串就是字符的序列。
當(dāng)執(zhí)行String a="abc";時，JAVA虛擬機會在棧中創(chuàng)建三個char型的值'a'、'b'和'c'，然后在堆中創(chuàng)建一個String對象，它的值（value）是剛才在棧中創(chuàng)建的三個char型值組成的數(shù)組{'a','b','c'}，最后這個新創(chuàng)建的String對象會被添加到字符串池中。如果我們接著執(zhí)行String b=new String("abc");代碼，由于"abc"已經(jīng)被創(chuàng)建并保存于字符串池中，因此JAVA虛擬機只會在堆中新創(chuàng)建一個String對象，但是它的值（value）是共享前一行代碼執(zhí)行時在棧中創(chuàng)建的三個char型值值'a'、'b'和'c'。
說到這里，我們對于篇首提出的String str=new String("abc")為什么是創(chuàng)建了兩個對象這個問題就已經(jīng)相當(dāng)明了了。

最新評論