多態主要是通過編譯時綁定實現的

Ⅰ 什麼叫做多態性 在C++中是如何實現多態的

C++中的多態（雖然多態不是C++所特有的，但是C++中的多態確實是很特殊的）分為靜多態和動多態（也就是靜態綁定和動態綁定兩種現象），靜動的區別主要在於這種綁定發生在編譯期還是運行期，發生在編譯期的是靜態綁定，也就是靜多態；發生在運行期的則是動態綁定，也就是動多態。

靜多態可以通過模板和函數重載來實現（之所說C++中的多態主要還是因為模板這個東西），下面舉兩個例子：
1）函數模板
template <typename T>
T max(const T& lsh, const T& rhs)
{
return (lsh > rhs) ? lsh : rhs;
}
返回兩個任意類型對象的最大值（對象），前提是該類型能夠使用>運算符進行比較，並且返回值是bool類型。
使用：
int a = 3; int b = 4;
cout << max(a, b) << endl;
float c = 2.4; float d = 1.2;
cout << max(c, d) << endl;
輸出結果為：
4
2.4
這種綁定發生在編譯期，這是由於模板的實例化是發生在編譯期的，即在編譯時編譯器發現你調用max(a, b)時就自動生成一個函數
int max(const int& lsh, const int& rhs)
{
return (lsh > rhs) ? lsh : rhs;
}
即將所有的T替換成int;
當你調用max(c, d)時就自動生成一個函數
float max(const float& lsh, const float& rhs)
{
return (lsh > rhs) ? lsh : rhs;
}
之所以說開始的函數定義是函數模板，就是因為他就像個模子似的，你可以用鋁作為原料也可以用石膏或者銅。
2）函數重載：
int max (int a, int b)
{
return (a > b) ? a : b;
}
int max (int a, int b, int c)
{
return max(max(a, b), c);
}
兩個函數名稱一樣，參數類型或個數不完全相同，返回值一樣（這個不重要）。
使用：
int a = 3, b = 4, c = 5;
cout << max(a, b) << endl;
cout << max(a, b, c) << endl;
輸出結果為：
4
5
確定函數的過程也發生在編譯器，當你使用max(a, b)，編譯器發現只有兩個參數，那麼就調用只有兩個參數的函數版本，當使用max(a, b, c)時，編譯器則使用有3個參數的版本。
通過上面的兩個例子，你還可以使用更為方便的模板函數重載：
template <typename T>
T max(const T& lsh, const T& rhs)
{
return (lsh > rhs) ? lsh : rhs;
}

template <typename T>
T max(const T& a, const T& b, const T& c)
{
return max(max(a, b), c);
}
使用
float a = 3.6, b = 1.2, c = 7.8;
cout << max(a, b, c) << endl;
輸出：
7.8
通過參數個數和類型，編譯器自動生成和調用對應得函數版本！

動多態則是通過繼承、虛函數(virtual)、指針來實現。
class A {
public:
virtual void func() const {
coust << 「A::func()」 << endl;
}
}

class B : public A {
public:
virtual void func() const {
coust << 「B::func()」 << endl;
}
}
使用：
A a* = B();
a->func();
輸出：
B::func()
編譯期是不調用任何函數的，編譯器編譯到a->func()時只是檢查有沒有語法問題，經過檢查沒有。編譯器並不知道調用的是A版本的func()還是B版本的func()，由於a是一個指向B對象的指針，所以a只知道它指向的是一個A類型（或者能轉換成A類型）的對象。通常集成體系就說明了（由於是公有繼承）B是一種A。在運行期，a要調用a所指向對象的func()函數，就對它指向的對象下達調用func()的命令，結果a所指向的是一個B對象，這個對象就調用了自己版本（B版）的func()函數，所以輸出時B::func()

總結：
在編譯期決定你應該調用哪個函數的行為是靜態綁定（static-binding)，這種現象就是靜多態。
在運行期決定應該調用哪中類型對象的函數的行為是動態綁定（dynamic-binding），這種現象就是動多態！

註：由於這是我花了有限的時間總結的，語言應用能力比較差，還有比如類模板（靜多態和動多態組合的情況）都沒有說，最近比較忙，請見諒！

如果還不是很懂，我建議你看C++Primer 4th Edition，講的比較清晰，但是比較零散！

Ⅱ java的多態怎麼實現

實現多態的三個條件（前提條件，向上轉型、向下轉型）
1、繼承的存在；（繼承是多態的基礎，沒有繼承就沒有多態）
2、子類重寫父類的方法。（多態下會調用子類重寫後的方法）
3、父類引用變數指向子類對象。（涉及子類到父類的類型轉換）
向上轉型 Student person = new Student()
將一個父類的引用指向一個子類對象，成為向上轉型，自動進行類型轉換。此時通過父類引用變數調用的方法是子類覆蓋或繼承父類的方法，而不是父類的方法此時通過父類引用變數無法調用子類特有的方法。
向下轉型 Student stu = (Student)person;
將一個指向子類對象的引用賦給一個子類的引用，成為向下轉型，此時必須進行強制類型轉換。向下轉型必須轉換為父類引用指向的真實子類類型，，否則將出現ClassCastException，不是任意的強制轉換
向下轉型時可以結合使用instanceof運算符進行強制類型轉換，比如出現轉換異常---ClassCastException

Ⅲ 編譯時的多態性和運行時的多態性在實現方法上有何不同

我不知道你哪本書上看到的，但是，只要不是後綁定就不能稱為多態，前綁定只能稱為代碼重用，比如函數的重載、覆蓋以及一般的類繼承。
多態的關鍵特點就是：在運行時虛基類指針指向派生類對象地址，而將派生類對象地址賦值給基類指針，這就是所謂的後綁定，編譯時綁定稱為前綁定，因此多態另一個特點就是「動態「。換句話說，如果是後綁定，編譯器事先是不知道在運行時指針將指向哪一種派生類的對象，因此基類指針必須是「虛「的，虛基類中不能有任何實現只有定義，此時虛基類的作用就是一個類介面，這樣才能在編譯時「模糊」掉類型匹配原則，基類的作用只是個約定，定義了函數調用格式，而只在運行時才確定指針具體指向哪一個對象。
而所謂編譯時的多態性根本不存在，如果編譯器能確定基類指針指向哪一個派生類對象地址，就不是多態，哪怕你採用重載覆蓋或者繼承，這些編譯器已經可以預知的事情，一旦編譯完成就固定了，運行時無法更改的，比如你不能在不重新編譯的情況下增加一個重載，這就制約了程序運行時的靈活性以及可擴充性。而多態完全可以實現「熱「更新，更多的是便於程序的可擴充性。你完全可以將派生類編譯在DLL中，每當更新程序時，只要替換掉DLL而不用重新編譯全部代碼。

Ⅳ C++多態是怎麼實現的

1、C++中，在調用重載函數時，能夠根據參數的類型及個數來找到確定的函數。然而，這一過程是通過編譯來完成的，也就是說，程序中尋找重載函數具體地址的工作是在程序編譯過程中完成的，程序一旦編譯完成，所有函數、方法等（包括重載函數、方法）的調用地址都已明確。
2、C++中，多態是運行時特徵，也就是說，程序實現多態是在程序運行的過程中來實現的。這一過程通常是針對虛擬類或方法來的，即在程序運行過程中動態的確定虛擬類或方法的地址，從而實現具體的類或方法的調用。
3、根據樓主的舉例，實現多態輸入，無非是希望程序在運行過程中，自動區分輸入內容的數據類型，此後程序根據具體的數據類型來調用相應的方法。由上述2所述，C++程序不具備針對變數的多態特性。因此，如果要實現這類「多態」，仍舊是程序員的職責，即程序員在代碼中來實現輸入的內容的具體數據類型。

Ⅳ 多態的原理是什麼

在編程語言和類型論中，多態（英語：polymorphism）指為不同數據類型的實體提供統一的介面。 多態類型（英語：polymorphic type）可以將自身所支持的操作套用到其它類型的值上。

計算機程序運行時，相同的消息可能會送給多個不同的類別之對象，而系統可依據對象所屬類別，引發對應類別的方法，而有不同的行為。簡單來說，所謂多態意指相同的消息給予不同的對象會引發不同的動作。

多態也可定義為「一種將不同的特殊行為和單個泛化記號相關聯的能力」。

(5)多態主要是通過編譯時綁定實現的擴展閱讀：

多態可分為變數多態與函數多態。變數多態是指：基類型的變數（對於C++是引用或指針）可以被賦值基類型對象，也可以被賦值派生類型的對象。函數多態是指，相同的函數調用界面（函數名與實參表），傳送給一個對象變數，可以有不同的行為，這視該對象變數所指向的對象類型而定。因此，變數多態是函數多態的基礎。

多態還可分為：動態多態（dynamic polymorphism）和靜態多態（static polymorphism）。

對於C++語言，帶變數的宏和函數重載（function overload）機制也允許將不同的特殊行為和單個泛化記號相關聯。然而，習慣上並不將這種函數多態（function polymorphism）、宏多態（macro polymorphism）展現出來的行為稱為多態（或靜態多態），否則就連C語言也具有宏多態了。談及多態時，默認就是指動態多態，而靜態多態則是指基於模板的多態。

Ⅵ java中多態性什麼意思

多態性：顧名思義就是擁有「多種形態」的含義，是指屬性或方法在子類中表現為多種形態。

在JAVA中有兩種多態是指：運行時多態和編譯時多態。多態性是面向對象的核心特徵之一,類的多態性提供類中成員設計的靈活性和方法執行的多樣性。

多態指允許不同類的對象對同一消息做出響應。即同一消息可以根據發送對象的不同而採用多種不同的行為方式。（發送消息就是函數調用）

實現多態的技術稱為：動態綁定（dynamic binding），是指在執行期間判斷所引用對象的實際類型，根據其實際的類型調用其相應的方法。

擴展資料:

多態的好處：

1、可替換性（substitutability）多態對已存在代碼具有可替換性。例如，多態對圓Circle類工作，對其他任何圓形幾何體，如圓環，也同樣工作。

2、可擴充性（extensibility）多態對代碼具有可擴充性。增加新的子類不影響已存在類的多態性、繼承性，以及其他特性的運行和操作。實際上新加子類更容易獲得多態功能。

3、介面性（interface-ability）多態是超類通過方法簽名，向子類提供了一個共同介面，由子類來完善或者覆蓋它而實現的。

4、靈活性（flexibility）它在應用中體現了靈活多樣的操作，提高了使用效率。

5、簡化性（simplicity）多態簡化對應用軟體的代碼編寫和修改過程，尤其在處理大量對象的運算和操作時，這個特點尤為突出和重要。

Ⅶ c++多態的實現方式有哪些

c++是一種編程語言，當然只有一種。但是基於c++的編程平台有很多種。

在這些平台上編程序，用的語言是c++的，但是在一些細節上會有所不同。我接觸過的主要有vc++，symbian c++，borland c++，它們都是基於c++的，但是編程風格或方式稍有不同。

你學c++要打好基礎，先學好c++語言。看書的時候可以找一些書名為「c++編程語言」之類的書，只有在學好c++語言後，才可以去具體的學習某個平台的編程教程。

一般來說，多態分為兩種，靜態多態和動態多態。靜態多態也稱編譯時多態，主要包括模板和重載。而動態多態則是通過類的繼承和虛函數來實現，當基類和子類擁有同名同參同返回的方法，且該方法聲明為虛方法。

當基類對象，指針，引用指向的是派生類的對象的時候，基類對象，指針，引用在調用基類的虛函數，實際上調用的是派生類函數。這就是動態多態。

靜態多態的實現。

靜態多態靠編譯器來實現，簡單來說就是編譯器對原來的函數名進行修飾，在c語言中，函數無法重載，是因為，c編譯器在修飾函數時，只是簡單的在函數名前加上下劃線」_」 ,不過從gcc編譯器編譯之後發現函數名並不會發生變化。

而c++編譯器不同，它根據函數參數的類型，個數來對函數名進行修飾，這就使得函數可以重載，同理，模板也是可以實現的，針對不同類型的實參來產生對應的特化的函數，通過增加修飾，使得不同的類型參數的函數得以區分。

Ⅷ 1． 編譯時的多態性與運行時的多態性有什麼區別，他們的實現方法有什麼不同

多態從實現的角度可以劃為兩類：編譯時多態和運行時多態。

編譯時的多態性:就是在程序編譯的時候，也就是生成解決方案的時候就決定要實現什麼操作。

運行時的多態性:就是指直到系統運行時,才根據實際情況決定實現何種操作。

1、多態實現形式不同：

編譯時的多態是通過靜態連編來實現的；運行時的多態是用動態連編來實現的。

2、多態性通過方式不同：

編譯時的多態性主要是通過函數重載和運算符重載來實現的；運行時的多態性主要是通過虛函數來實現的。

(8)多態主要是通過編譯時綁定實現的擴展閱讀：

靜態多態性又稱編譯時的多態性。靜態多態性的函數調用速度快、效率高但缺乏靈活性,在程序運行前就應決定執行的函數和方法。

動態多態性的特點是:不在編譯時確定調用的是哪個函數，而是在程序運行過程中才動態地確定操作所針對的對象。又稱運行時的多態性。動態多態性是通過虛函數(virtual function)實現的。

Ⅸ 什麼是多態性，使用多態有什麼好處

什麼是多態？

可以這么回答：

• 父類引用
  引用子類對象

• 父類和子類有同名的覆蓋方法

• 通過父類引用調用這個重寫的方法的時候。多數的話就可以稱為多態，單數可以說運行時綁定。

使用多態有什麼好處？

• 類調用者對類的使用成本進一步降低

• 封裝是讓類的調用者不需要知道類的實現細節，多態能讓類的調用者連這個類的類型是什麼都不必知道，只需要知道這個對象具有某個方法即可。因此，多態可以理解成是封裝的更進一步，讓類調用者對類的使用成本進一步降低。

• 能夠降低代碼的「圈復雜度」，避免使用大量的if-else

多態在代碼中的體現：

輸出結果：
貓吃魚
貓吃魚（因為描述的是真正的是一隻貓）

拓展：

多態性：同一操作作用於不同的對象，可以用不同的解釋，產生不同的執行結果，這就是多態性。

多態性通過派生類覆寫基類中的虛函數的方法來實現。

多態性分為兩種，一種是編譯時的多態性，一種是運行時的多態性。

編譯時的多態性：編譯時多態是通過重載來實現的。對於非虛的成員來說，系統在編譯時，根據傳遞的參數，返回的類型等信息決定實現何種操作。

運行時的多態性：運行時的多態性就是指直到系統運行時，才根據實際情況決定實現何種操作。