多態是運行時還是編譯時

Ⅰ 請問 c++中 模板是 編譯時多態還是運行時多態，或者都不是，求解

是編譯時多態。所有的模板都是在編譯時產生對應的代碼，它沒有面向對象中的虛表，無法實現動態多態。

你仔細想一想，模板在應用時都必須指定確定的類型，而運行多態僅需指定一個基類就OK啦。

Ⅱ java中多態性什麼意思

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

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

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

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

擴展資料:

多態的好處：

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

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

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

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

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

Ⅲ 關於Java的編譯時多態和運行時多態

您想的有點復雜化了，簡單的說吧，您說的運行時的多態是分為可執行文件和非可執行文件，也就是說您的程序打沒打包，而您說的編譯時的多態也分為兩種；1、重載。2、繼承。前者是靜態的多態形式也就是說不可以用於多個類；針對方法，後者是可以在多個類之間使用，要記得只可以子類繼承父類，不可『以下犯上』。就像是java中的類型，一個是private，另一個是public。

Ⅳ 什麼是多態

多態首先是建立在繼承的基礎上的，先有繼承才能有多態。多態是指不同的子類在繼承父類後分別都重寫覆蓋了父類的方法，即父類同一個方法，在繼承的子類中表現出不同的形式。多態成立的另一個條件是在創建子類時候必須使用父類new子類的方式。

多態（Polymorphism）按字面的意思就是「多種狀態」。在面向對象語言中，介面的多種不同的實現方式即為多態。引用Charlie Calverts對多態的描述——多態性是允許你將父對象設置成為一個或更多的他的子對象相等的技術，賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作（摘自「Delphi4編程技術內幕」）。

簡單的說，就是一句話：允許將子類類型的指針賦值給父類類型的指針。多態性在Object Pascal和C++中都是通過虛函數實現的。

拓展資料：

多態指同一個實體同時具有多種形式。它是面向對象程序設計（OOP）的一個重要特徵。如果一個語言只支持類而不支持多態，只能說明它是基於對象的，而不是面向對象的。C++中的多態性具體體現在運行和編譯兩個方面。運行時多態是動態多態，其具體引用的對象在運行時才能確定。編譯時多態是靜態多態，在編譯時就可以確定對象使用的形式。

多態：同一操作作用於不同的對象，可以有不同的解釋，產生不同的執行結果。在運行時，可以通過指向基類的指針，來調用實現派生類中的方法。

C++中，實現多態有以下方法：虛函數，抽象類，覆蓋，模板（重載和多態無關）。

OC中的多態：不同對象對同一消息的不同響應.子類可以重寫父類的方法。

多態就是允許方法重名 參數或返回值可以是父類型傳入或返回。

多態也指生物學中腔腸動物的特殊的生活方式。水螅態與水母態的世代交替現象。

把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應需求的不斷變化。

賦值之後，父類型的引用就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。

使用繼承性的結果就是當創建了一個類的家族，在認識這個類的家族時，就是把子類的對象當作基類的對象，這種認識又叫作upcasting（向上轉型）。這樣認識的重要性在於：我們可以只針對基類寫出一段程序，但它可以適應於這個類的家族，因為編譯器會自動找出合適的對象來執行操作。這種現象又稱為多態性。而實現多態性的手段又叫稱動態綁定(dynamic binding)。

簡單的說，建立一個父類對象的引用，它所指對象可以是這個父類的對象，也可以是它的子類的對象。java中當子類擁有和父類同樣的函數，當通過這個父類對象的引用調用這個函數的時候，調用到的是子類中的函數。

Ⅳ 多態的表現形式是什麼

多態指同一個實體同時具有多種形式。它是面向對象程序設計（OOP）的一個重要特徵。如果一個語言只支持類而不支持多態，只能說明它是基於對象的，而不是面向對象的。C++中的多態性具體體現在運行和編譯兩個方面。

運行時多態是動態多態，其具體引用的對象在運行時才能確定。編譯時多態是靜態多態，在編譯時就可以確定對象使用的形式。

多態：同一操作作用於不同的對象，可以有不同的解釋，產生不同的執行結果。在運行時，可以通過指向基類的指針，來調用實現派生類中的方法。

C++中，實現多態有以下方法：虛函數，抽象類，覆蓋，模板（重載和多態無關）。

OC中的多態：不同對象對同一消息的不同響應.子類可以重寫父類的方法

多態就是允許方法重名 參數或返回值可以是父類型傳入或返回。

多態也指生物學中腔腸動物的特殊的生活方式。水螅態與水母態的世代交替現象。

(5)多態是運行時還是編譯時擴展閱讀：

多態作用：

把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應需求的不斷變化。

賦值之後，父類型的引用就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。

舉個例子：從一個基類中派生，響應一個虛命令，產生不同的結果。

比如從某個基類派生出多個子類，其基類有一個虛方法Tdoit，然後其子類也有這個方法，但行為不同，然後這些子類對象中的任何一個可以賦給其基類對象的引用。

或者說將子對象地址賦給基類指針，這樣其基類的對象就可以執行不同的操作了。實際上你是在通過其基類的引用來訪問其子類對象的，你要做的就是一個賦值操作。

使用繼承性的結果就是當創建了一個類的家族，在認識這個類的家族時，就是把子類的對象當作基類的對象，這種認識又叫作upcasting（向上轉型）。

這樣認識的重要性在於：我們可以只針對基類寫出一段程序，但它可以適應於這個類的家族，因為編譯器會自動找出合適的對象來執行操作。這種現象又稱為多態性。而實現多態性的手段又叫稱動態綁定(dynamic binding)。

Ⅵ C++多態性的定義到底是什麼

1. C++編程語言是一款應用廣泛，支持多種程序設計的計算機編程語言。我們今天就會為大家詳細介紹其中C++多態性的一些基本知識，以方便大家在學習過程中對此能夠有一個充分的掌握。
2. 多態性可以簡單地概括為「一個介面，多種方法」，程序在運行時才決定調用的函數，它是面向對象編程領域的核心概念。多態(polymorphism)，字面意思多種形狀。
3.C++多態性是通過虛函數來實現的，虛函數允許子類重新定義成員函數，而子類重新定義父類的做法稱為覆蓋(override)，或者稱為重寫。（這里我覺得要補充，重寫的話可以有兩種，直接重寫成員函數和重寫虛函數，只有重寫了虛函數的才能算作是體現了C++多態性）而重載則是允許有多個同名的函數，而這些函數的參數列表不同，允許參數個數不同，參數類型不同，或者兩者都不同。編譯器會根據這些函數的不同列表，將同名的函數的名稱做修飾，從而生成一些不同名稱的預處理函數，來實現同名函數調用時的重載問題。但這並沒有體現多態性。
4.多態與非多態的實質區別就是函數地址是早綁定還是晚綁定。如果函數的調用，在編譯器編譯期間就可以確定函數的調用地址，並生產代碼，是靜態的，就是說地址是早綁定的。而如果函數調用的地址不能在編譯器期間確定，需要在運行時才確定，這就屬於晚綁定。
5.那麼多態的作用是什麼呢，封裝可以使得代碼模塊化，繼承可以擴展已存在的代碼，他們的目的都是為了代碼重用。而多態的目的則是為了介面重用。也就是說，不論傳遞過來的究竟是那個類的對象，函數都能夠通過同一個介面調用到適應各自對象的實現方法。
6.最常見的用法就是聲明基類的指針，利用該指針指向任意一個子類對象，調用相應的虛函數，可以根據指向的子類的不同而實現不同的方法。如果沒有使用虛函數的話，即沒有利用C++多態性，則利用基類指針調用相應的函數的時候，將總被限制在基類函數本身，而無法調用到子類中被重寫過的函數。因為沒有多態性，函數調用的地址將是一定的，而固定的地址將始終調用到同一個函數，這就無法實現一個介面，多種方法的目的了。

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

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

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

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

1、多態實現形式不同：

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

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

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

(7)多態是運行時還是編譯時擴展閱讀：

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

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

Ⅷ 談談你對Java中的多態的理解.(為什麼要使用多態，有什麼好處，一般用在什麼場合)

面向對象編程有三大特性：封裝、繼承、多態。

封裝隱藏了類的內部實現機制，可以在不影響使用的情況下改變類的內部結構，同時也保護了數據。對外界而已它的內部細節是隱藏的，暴露給外界的只是它的訪問方法。

繼承是為了重用父類代碼。兩個類若存在IS-A的關系就可以使用繼承。，同時繼承也為實現多態做了鋪墊。

那麼什麼是多態呢？多態的實現機制又是什麼？請看我一一為你揭開：

所謂多態

就是指程序中定義的引用變數所指向的具體類型和通過該引用變數發出的方法調用在編程時並不確定，而是在程序運行期間才確定，即一個引用變數倒底會指向哪個類的實例對象，該引用變數發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變數綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。

比如你是一個酒神，對酒情有獨鍾。某日回家發現桌上有幾個杯子裡面都裝了白酒，從外面看我們是不可能知道這是些什麼酒，只有喝了之後才能夠猜出來是何種酒。你一喝，這是劍南春、再喝這是五糧液、再喝這是酒鬼酒….在這里我們可以描述成如下：

酒 a = 劍南春

酒 b = 五糧液

酒 c = 酒鬼酒

…

這里所表現的的就是多態。劍南春、五糧液、酒鬼酒都是酒的子類，我們只是通過酒這一個父類就能夠引用不同的子類，這就是多態——我們只有在運行的時候才會知道引用變數所指向的具體實例對象。

誠然，要理解多態我們就必須要明白什麼是「向上轉型」。在繼承中我們簡單介紹了向上轉型，這里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父類，劍南春（JNC）、五糧液（WLY）、酒鬼酒（JGJ）是子類。我們定義如下代碼：

JNC a = new JNC();

對於這個代碼我們非常容易理解無非就是實例化了一個劍南春的對象嘛！但是這樣呢？

Wine a = new JNC();

在這里我們這樣理解，這里定義了一個Wine 類型的a，它指向JNC對象實例。由於JNC是繼承與Wine，所以JNC可以自動向上轉型為Wine，所以a是可以指向JNC實例對象的。這樣做存在一個非常大的好處，在繼承中我們知道子類是父類的擴展，它可以提供比父類更加強大的功能，如果我們定義了一個指向子類的父類引用類型，那麼它除了能夠引用父類的共性外，還可以使用子類強大的功能。

但是向上轉型存在一些缺憾，那就是它必定會導致一些方法和屬性的丟失，而導致我們不能夠獲取它們。所以父類類型的引用可以調用父類中定義的所有屬性和方法，對於只存在與子類中的方法和屬性它就望塵莫及了。

publicclassWine{
publicvoidfun1(){
System.out.println("Wine的Fun.....");
fun2();
}

publicvoidfun2(){
System.out.println("Wine的Fun2...");
}
}

publicclassJNCextendsWine{
/**
*@desc子類重載父類方法
*父類中不存在該方法，向上轉型後，父類是不能引用該方法的
*@parama
*@returnvoid
*/
publicvoidfun1(Stringa){
System.out.println("JNC的Fun1...");
fun2();
}

/**
*子類重寫父類方法
*指向子類的父類引用調用fun2時，必定是調用該方法
*/
publicvoidfun2(){
System.out.println("JNC的Fun2...");
}
}

publicclassTest{
publicstaticvoidmain(String[]args){
Winea=newJNC();
a.fun1();
}
}

-------------------------------------------------

Output:

Wine的Fun.....

JNC的Fun2...

從程序的運行結果中我們發現，a.fun1()首先是運行父類Wine中的fun1().然後再運行子類JNC中的fun2()。

分析：在這個程序中子類JNC重載了父類Wine的方法fun1()，重寫fun2()，而且重載後的fun1(String a)與 fun1()不是同一個方法，由於父類中沒有該方法，向上轉型後會丟失該方法，所以執行JNC的Wine類型引用是不能引用fun1(String a)方法。而子類JNC重寫了fun2() ，那麼指向JNC的Wine引用會調用JNC中fun2()方法。

所以對於多態我們可以總結如下：

指向子類的父類引用由於向上轉型了，它只能訪問父類中擁有的方法和屬性，而對於子類中存在而父類中不存在的方法，該引用是不能使用的，盡管是重載該方法。若子類重寫了父類中的某些方法，在調用該些方法的時候，必定是使用子類中定義的這些方法（動態連接、動態調用）。

對於面向對象而已，多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的重載，它是根據參數列表的不同來區分不同的函數，通過編輯之後會變成兩個不同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來實現的，也就是我們所說的多態性。

多態的實現

2.1實現條件

在剛剛開始就提到了繼承在為多態的實現做了准備。子類Child繼承父類Father，我們可以編寫一個指向子類的父類類型引用，該引用既可以處理父類Father對象，也可以處理子類Child對象，當相同的消息發送給子類或者父類對象時，該對象就會根據自己所屬的引用而執行不同的行為，這就是多態。即多態性就是相同的消息使得不同的類做出不同的響應。

Java實現多態有三個必要條件：繼承、重寫、向上轉型。

繼承：在多態中必須存在有繼承關系的子類和父類。

重寫：子類對父類中某些方法進行重新定義，在調用這些方法時就會調用子類的方法。

向上轉型：在多態中需要將子類的引用賦給父類對象，只有這樣該引用才能夠具備技能調用父類的方法和子類的方法。

只有滿足了上述三個條件，我們才能夠在同一個繼承結構中使用統一的邏輯實現代碼處理不同的對象，從而達到執行不同的行為。

對於Java而言，它多態的實現機制遵循一個原則：當超類對象引用變數引用子類對象時，被引用對象的類型而不是引用變數的類型決定了調用誰的成員方法，但是這個被調用的方法必須是在超類中定義過的，也就是說被子類覆蓋的方法。

2.2實現形式

在Java中有兩種形式可以實現多態。繼承和介面。

2.2.1、基於繼承實現的多態

基於繼承的實現機制主要表現在父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫可以表現出不同的行為。

publicclassWine{
privateStringname;

publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

publicWine(){
}

publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
returnnull;
}
}

publicclassJNCextendsWine{
publicJNC(){
setName("JNC");
}

/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}

publicclassJGJextendsWine{
publicJGJ(){
setName("JGJ");
}

/**
*重寫父類方法，實現多態
*/
publicStringdrink(){
return"喝的是"+getName();
}

/**
*重寫toString()
*/
publicStringtoString(){
return"Wine:"+getName();
}
}

publicclassTest{
publicstaticvoidmain(String[]args){
//定義父類數組
Wine[]wines=newWine[2];
//定義兩個子類
JNCjnc=newJNC();
JGJjgj=newJGJ();

//父類引用子類對象
wines[0]=jnc;
wines[1]=jgj;

for(inti=0;i<2;i++){
System.out.println(wines[i].toString()+"--"+wines[i].drink());
}
System.out.println("-------------------------------");

}
}

OUTPUT:

Wine:JNC--喝的是JNC

Wine:JGJ--喝的是JGJ

在上面的代碼中JNC、JGJ繼承Wine，並且重寫了drink()、toString()方法，程序運行結果是調用子類中方法，輸出JNC、JGJ的名稱，這就是多態的表現。不同的對象可以執行相同的行為，但是他們都需要通過自己的實現方式來執行，這就要得益於向上轉型了。

我們都知道所有的類都繼承自超類Object，toString()方法也是Object中方法，當我們這樣寫時：

Objecto=newJGJ();

System.out.println(o.toString());

輸出的結果是Wine : JGJ。

Object、Wine、JGJ三者繼承鏈關系是：JGJ—>Wine—>Object。所以我們可以這樣說：當子類重寫父類的方法被調用時，只有對象繼承鏈中的最末端的方法才會被調用。但是注意如果這樣寫：

Objecto=newWine();

System.out.println(o.toString());

輸出的結果應該是Null，因為JGJ並不存在於該對象繼承鏈中。

所以基於繼承實現的多態可以總結如下：對於引用子類的父類類型，在處理該引用時，它適用於繼承該父類的所有子類，子類對象的不同，對方法的實現也就不同，執行相同動作產生的行為也就不同。

如果父類是抽象類，那麼子類必須要實現父類中所有的抽象方法，這樣該父類所有的子類一定存在統一的對外介面，但其內部的具體實現可以各異。這樣我們就可以使用頂層類提供的統一介面來處理該層次的方法。

2.2.2、基於介面實現的多態

繼承是通過重寫父類的同一方法的幾個不同子類來體現的，那麼就可就是通過實現介面並覆蓋介面中同一方法的幾不同的類體現的。

在介面的多態中，指向介面的引用必須是指定這實現了該介面的一個類的實常式序，在運行時，根據對象引用的實際類型來執行對應的方法。

繼承都是單繼承，只能為一組相關的類提供一致的服務介面。但是介面可以是多繼承多實現，它能夠利用一組相關或者不相關的介面進行組合與擴充，能夠對外提供一致的服務介面。所以它相對於繼承來說有更好的靈活性。