多態分為編譯時和運行時

㈠ java的多態有什麼特點什麼地方適合使用多態

多態性是指允許不同子類型的對象對同一消息作出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情。多態性分為編譯時的多態性和運行時的多態性。
如果將對象的方法視為對象向外界提供的服務，那麼運行時的多態性可以解釋為：當A系統訪問B系統提供的服務時，B系統有多種提供服務的方式，但一切對A系統來說都是透明的（就像電動剃須刀是A系統，它的供電系統是B系統，B系統可以使用電池供電或者用交流電，甚至還有可能是太陽能，A系統只會通過B類對象調用供電的方法，但並不知道供電系統的底層實現是什麼，究竟通過何種方式獲得了動力）。
方法重載（overload）實現的是編譯時的多態性（也稱為前綁定），而方法重寫（override）實現的是運行時的多態性（也稱為後綁定）。

㈡ C++支持兩種類型的多態性：_________、運行時多態

（1）編譯時的多態性
編譯時的多態性是通過重載來實現的。對於非虛的成員來說，系統在編譯時，根據傳遞的參數、返回的類型等信息決定實現何種操作。
（2）運行時的多態性
運行時的多態性就是指直到系統運行時，才根據實際情況決定實現何種操作。C++中，運行時的多態性通過虛成員實現。

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

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

㈣ 什麼是多態實現多態的機制是什麼

面試官：什麼是多態呢？
豬隊友：多種形態，氣體，液體，固體~
面試官：go out! now!

到底什麼是多態呢？

允許將子類類型的指針賦值給父類類型的指針，把不同的子類對象都當作父類來看。比如你家有親屬結婚了，讓你們家派個人來參加婚禮，邀請函寫的是讓你爸來，但是實際上你去了，或者你妹妹去了，這都是可以的，因為你們代表的是你爸，但是在你們去之前他們也不知道誰會去，只知道是你們家的人。可能是你爸爸，可能是你們家的其他人代表你爸參加。這就是多態。

多態又分為 編譯時多態和運行時多態。
編譯時多態：比如重載
運行時多態：比如重寫

簡單版本：

原理也很簡單，父類或者介面定義的引用變數可以指向子類或者具體實現類的實例對象，由於程序調用方法是在運行期才動態綁定的，那麼引用變數所指向的具體實例對象在運行期才確定。所以這個對象的方法是運行期正在內存運行的這個對象的方法而不是引用變數的類型中定義的方法。

術語版本：

我們將引入Java靜態分派和動態分派這個概念。

如果想深入的同學可以參考可以參考《深入理解Java虛擬機》。

參考：
https://blog.csdn.net/sunxianghuang/article/details/52280002

㈤ java中多態性什麼意思

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

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

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

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

擴展資料:

多態的好處：

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

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

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

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

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

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

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

㈦ 多態的表現形式是什麼

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

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

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

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

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

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

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

(7)多態分為編譯時和運行時擴展閱讀：

多態作用：

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

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

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

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

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

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

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

㈧ 運行時多態和編譯時多態

多態：多態的概念比較簡單，就是同一操作作用於不同的對象，可以有不同的解釋，產生不同

的執行結果。

運行時多態：重寫就是一種運行時多態。只有在運行過程中才能清楚調用的是具體的那個方法。

重寫的情況：

public class Dog {

        public void bark(){

            System.out.println("woof ");

        }

  private static  class Hound extends Dog{

        public void sniff(){

            System.out.println("sniff ");

        }

        public void bark(){

            System.out.println("bowl"); }

    }

    public static void main(String [] args){

            Dog dog = new Hound();

            dog.bark();

            Dog dog1=new Dog();

            dog1.bark();

        }

    }

輸出結果是：

bowl

woof

父類引用指向子類對象情況：

public class Parent{

public void call(){

sout("im Parent");

}

}

public class Son extends Parent{// 1.有類繼承或者介面實現

public void call(){// 2.子類要重寫父類的方法

sout("im Son");

}

}

public class Daughter extends Parent{// 1.有類繼承或者介面實現

public void call(){// 2.子類要重寫父類的方法

sout("im Daughter");

}

}

public class Test{

public static void main(String[] args){

Parent p = new Son(); //3.父類的引用指向子類的對象

Parent p1 = new Daughter(); //3.父類的引用指向子類的對象

p.call();

p1.call();

}

}

輸出結果是：

im son

im Daughter

同樣是 Parent 類的實例，p.call 調用的是 Son 類的實現、p1.call 調用的是 Daughter 的實現。這里因為是自己定義的，所以可以在new對像的過程中就能明白p是son，p1是daughter。但是有的時候，我們無法直觀看到new對象的過程。比如說工廠模式、Spring的ioc。所以只有在程序運行的過程才能夠清楚具體調用的是誰的方法。

編譯時多態：Java中重載就是一種編譯時多態。程序處在編譯期間，通過參數的不同來決定具體調用的是那個方法。

思考：重載一定是發生在同一個類中嗎？子類是否可重載父類的方法？