多態性是物件導向程式設計的基本原則之一。它允許您利用 Java 強類型的強大功能並編寫可用且可維護的程式碼。關於他的說法已經很多了，但我希望每個人都能從這篇評論中得到一些新的東西。
![多態性及其朋友 - 1]()
![多態性及其朋友 - 2]()
例如，當宣告一個方法 public void method(Object o) 時，簽章將是方法的名稱和參數 Object 的型別。傳回類型不包含在簽名中。這很重要！接下來，讓我們編譯我們的原始碼。眾所周知，為此，程式碼必須保存在一個檔案中，該檔案的名稱為類別名，副檔名為 java.lang. Java 程式碼使用「javac」編譯器編譯成某種可以由 Java 虛擬機器 (JVM) 執行的中間格式。這種中間格式稱為字節碼，包含在副檔名為 .class 的檔案中。我們來執行命令進行編譯：
![Java-университет]()
![多態性及其朋友 - 3]()
從字節碼中我們可以看到，透過指定類別的類型的物件呼叫方法是使用 進行的
![多態性及其朋友 - 4]()
重寫或動態多態性。因此，我們首先儲存包含以下內容的 HelloWorld.java 檔案：
![多態性及其朋友 - 5]()
正如您所看到的，在包含方法呼叫的行的字節碼中，指示了對呼叫方法的相同參考
![多態性及其朋友 - 6]()
重新定義也與「協方差」的概念相關。讓我們來看一個例子：
![多態性及其朋友 - 7]()
![多態性及其朋友 - 8]()
![多態性及其朋友 - 9]()
也就是說，當重載時，編譯器會檢查正確性。這很重要。但是編譯器實際上如何決定需要呼叫某個方法呢？它使用Java語言規範中所描述的「最具體方法」規則：「15.12.2.5.選擇最具體方法」。為了示範它是如何運作的，我們以 Oracle 認證專業 Java 程式設計師為例：
![多態性及其朋友 - 10]()
事實證明，在編譯期間，有關參數類型和數量的資訊（在編譯時可用）將用於確定方法的簽章。如果該方法是物件的方法之一（即實例方法），則將在執行時間使用動態方法來尋找（即動態綁定）來確定實際的方法呼叫。為了更清楚地說明這一點，讓我們舉一個與前面討論的類似的例子：
![多態性及其朋友 - 11]()
如前所述，編譯器已確定將來將呼叫某些虛擬方法。也就是說，方法體將在運行時定義。但在編譯時，編譯器在這三種方法中選擇了最合適的一種，因此它顯示了數字：
![多態性及其朋友 - 12]()
這是什麼樣的methodref？這是該方法的連結。粗略地說，這是一些線索，在運行時，Java 虛擬機器實際上可以確定要尋找執行哪個方法。更多詳細內容可參考超級文章：《JVM如何在內部處理方法重載與重寫》。
介紹
我想我們都知道Java程式語言屬於Oracle。因此，我們的路徑從以下網站開始：www.oracle.com。主頁上有一個「選單」。其中，「文檔」部分有一個「Java」小節。所有與語言基本功能相關的內容都屬於“Java SE 文件”，因此我們選擇這一部分。文件部分將開啟最新版本，但現在“正在尋找不同的版本？” 讓我們選擇選項：JDK8。在頁面上我們會看到很多不同的選項。但我們對學習語言感興趣：「Java 教程學習路徑」。在此頁面上，我們會找到另一個部分：「學習 Java 語言」。這是最神聖的內容，來自 Oracle 的 Java 基礎知識教學。Java 是一種物件導向程式語言 (OOP)，因此即使在 Oracle 網站上學習該語言也是從討論「物件導向程式設計概念」的基本概念開始的。從名稱本身就可以清楚看出，Java 專注於處理物件。從「什麼是物件？」小節可以清楚看出，Java 中的物件由狀態和行為組成。想像一下我們有一個銀行帳戶。帳戶中的金額是一種狀態，而處理這種狀態的方法是行為。物件需要以某種方式進行描述（告訴它們可能具有什麼狀態和行為），而這種描述就是類別。當我們建立某個類別的物件時，我們指定該類，這稱為「物件類型」。因此，可以說 Java 是一種強類型語言，正如 Java 語言規範中「第 4 章類型、值和變數」部分所述。Java 語言遵循 OOP 概念並支援使用extends 關鍵字的繼承。為什麼要擴張？因為透過繼承，子類別繼承了父類別的行為和狀態，並且可以補充它們，即 擴充基底類別的功能。也可以使用implements 關鍵字在類別描述中指定介面。當一個類別實作一個介面時，這表示該類別符合某種契約－程式設計師向環境的其餘部分聲明該類別具有某種行為。例如，播放器有各種按鈕。這些按鈕是控製播放器行為的接口，行為會改變播放器的內部狀態（例如音量）。在這種情況下，狀態和行為作為描述將給出一個類別。如果一個類別實作了一個接口，那麼該類別創建的物件不僅可以透過類別來描述，還可以透過接口來描述。讓我們來看一個例子：public class MusicPlayer {
public static interface Device {
public void turnOn();
public void turnOff();
}
public static class Mp3Player implements Device {
public void turnOn() {
System.out.println("On. Ready for mp3.");
}
public void turnOff() {
System.out.println("Off");
}
}
public static class Mp4Player extends Mp3Player {
@Override
public void turnOn() {
System.out.println("On. Ready for mp3/mp4.");
}
}
public static void main(String []args) throws Exception{
// Какое-то устройство (Тип = Device)
Device mp3Player = new Mp3Player();
mp3Player.turnOn();
// У нас есть mp4 проигрыватель, но нам от него нужно только mp3
// Пользуемся им How mp3 проигрывателем (Тип = Mp3Player)
Mp3Player mp4Player = new Mp4Player();
mp4Player.turnOn();
}
}
javac MusicPlayer.java java程式碼編譯完成後，我們就可以執行它了。使用「java」實用程式啟動，將啟動java虛擬機器進程來執行類別檔案中傳遞的字節碼。讓我們運行命令來啟動應用程式：java MusicPlayer。我們將在螢幕上看到 println 方法的輸入參數中指定的文字。有趣的是，將字節碼放在擴展名為 .class 的檔案中，我們可以使用「javap」實用程式查看它。讓我們執行指令 <ocde>javap -c MusicPlayer：
invokevirtual，並且編譯器已經計算出應該使用哪個方法簽章。為什麼invokevirtual？因為有一個虛方法的呼叫（invoke翻譯為呼叫）。什麼是虛擬方法？這是一個在程式執行期間可以覆寫其主體的方法。簡單想像一下，您有一個特定金鑰（方法簽章）和方法主體（程式碼）之間的對應清單。並且鍵和方法體之間的這種對應關係可能會在程式執行過程中發生變化。因此該方法是虛擬的。預設情況下，在 Java 中，非靜態、非最終和非私有的方法是虛擬的。正因為如此，Java 支援物件導向的多型程式設計原則。正如您可能已經了解的那樣，這就是我們今天的評論的內容。
多態性
在 Oracle 網站的官方教學中，有一個單獨的部分：「多態性」。讓我們使用Java 線上編譯器來看看多態性在 Java 中是如何運作的。例如，我們有一些代表Java中數字的抽象類別Number 。它允許什麼？他擁有一些所有繼承人都會擁有的基本技術。任何繼承 Number 的人都會說：“我是一個數字，你可以將我作為一個數字來工作。” 例如，對於任何後繼，您可以使用 intValue() 方法來取得其 Integer 值。如果你看Number的java api，你會發現該方法是抽象的，也就是說，Number的每個後繼者都必須自己實作這個方法。但這為我們帶來了什麼？讓我們來看一個例子：public class HelloWorld {
public static int summ(Number first, Number second) {
return first.intValue() + second.intValue();
}
public static void main(String []args){
System.out.println(summ(1, 2));
System.out.println(summ(1L, 4L));
System.out.println(summ(1L, 5));
System.out.println(summ(1.0, 3));
}
}
public class HelloWorld {
public static class Parent {
public void method() {
System.out.println("Parent");
}
}
public static class Child extends Parent {
public void method() {
System.out.println("Child");
}
}
public static void main(String[] args) {
Parent parent = new Parent();
Parent child = new Child();
parent.method();
child.method();
}
}javac HelloWorld.java並且javap -c HelloWorld：
invokevirtual (#6)。我們開始做吧java HelloWorld。如我們所看到的，變數parent和child是用Parent類型宣告的，但根據指派給變數的物件（即物件的類型）來呼叫實作本身。在程式執行期間（他們也說在運行時），JVM根據物件的不同，在呼叫使用相同簽名的方法時，執行不同的方法。也就是說，使用對應簽署的金鑰，我們先收到一個方法體，然後再收到另一個方法體。取決於變數中的物件。在程式執行時確定將呼叫哪個方法也稱為後期綁定或動態綁定。也就是說，簽章和方法體之間的匹配是動態執行的，這取決於呼叫該方法的物件。當然，您不能覆寫類別的靜態成員（Class member），以及存取類型為 private 或 Final 的類別成員。@Override 註釋也可以為開發人員提供協助。它可以幫助編譯器理解此時我們將重寫祖先方法的行為。如果我們在方法簽章中犯了錯誤，編譯器會立即告訴我們。例如：
public static class Parent {
public void method() {
System.out.println("parent");
}
}
public static class Child extends Parent {
@Override
public void method(String text) {
System.out.println("child");
}
}
public class HelloWorld {
public static class Parent {
public Number method() {
return 1;
}
}
public static class Child extends Parent {
@Override
public Integer method() {
return 2;
}
}
public static void main(String[] args) {
System.out.println(new Child().method());
}
}
隱藏
還有一種說法叫做「隱瞞」。例子：public class HelloWorld {
public static class Parent {
public static void method() {
System.out.println("Parent");
}
}
public static class Child extends Parent {
public static void method() {
System.out.println("Child");
}
}
public static void main(String[] args) {
Parent parent = new Parent();
Parent child = new Child();
parent.method();
child.method();
}
}
重載方法
我們在 Java Oracle 教程中還看到了什麼？在前面學習的「定義方法」一節中，有一些關於重載的內容。這是什麼？在俄語中，這是“方法重載”，這樣的方法稱為“重載”。所以，方法重載。乍一看，一切都很簡單。讓我們開啟一個線上Java編譯器，例如tutorialspoint online java compiler。public class HelloWorld {
public static void main(String []args){
HelloWorld hw = new HelloWorld();
hw.say(1);
hw.say("1");
}
public static void say(Integer number) {
System.out.println("Integer " + number);
}
public static void say(String number) {
System.out.println("String " + number);
}
}
public class Overload{
public void method(Object o) {
System.out.println("Object");
}
public void method(java.io.FileNotFoundException f) {
System.out.println("FileNotFoundException");
}
public void method(java.io.IOException i) {
System.out.println("IOException");
}
public static void main(String args[]) {
Overload test = new Overload();
test.method(null);
}
}reference to method is ambiguous。再舉一個例子：
public class Overload{
public static void method(int... array) {
System.out.println("1");
}
public static void main(String args[]) {
method(1, 2);
}
}public static void method(long a, long b) {
System.out.println("2");
}public static void method(Integer a, Integer b) {
System.out.println("3");
}method(new Integer(1), new Integer(2));它將列印 3. Java 中的建構函數與方法類似，並且由於它們也可以用於獲取簽名，因此與重載方法一樣適用相同的「重載解析」規則。Java 語言規範在「8.8.8. 建構子重載」中告訴了我們這一點。方法重載 = 早期綁定（又稱靜態綁定） 您經常會聽到早期綁定和晚期綁定，也稱為靜態綁定或動態綁定。它們之間的差異非常簡單。早期是編譯，晚期是程式執行的時刻。因此，早期綁定（靜態綁定）就是在編譯時決定要對誰呼叫哪個方法。那麼，後期綁定（動態綁定）就是在程式執行時決定要直接呼叫哪個方法。正如我們之前看到的（當我們將 IOException 更改為 EOFException 時），如果我們重載方法，使編譯器無法理解在哪裡進行哪個調用，那麼我們將得到一個編譯時錯誤：對方法的引用不明確。英文中的ambiguously一詞翻譯過來的意思是不明確的或不確定的、不精確的。事實證明，重載是早期綁定，因為 檢查是在編譯時執行的。為了證實我們的結論，讓我們開啟Java語言規範中的「 8.4.9.重載」章節：
public class HelloWorld {
public void method(int intNumber) {
System.out.println("intNumber");
}
public void method(Integer intNumber) {
System.out.println("Integer");
}
public void method(String intNumber) {
System.out.println("Number is: " + intNumber);
}
public static void main(String args[]) {
HelloWorld test = new HelloWorld();
test.method(2);
}
}javac HelloWorld.java 現在讓我們透過執行以下命令來查看編譯器在字節碼中寫入的內容：javap -verbose HelloWorld。
"invokevirtual #13"
GO TO FULL VERSION