什么是多態(tài)？不同語言實(shí)現(xiàn)的方式

什么是多態(tài)

面向?qū)ο蟪绦蛟O(shè)計(jì)有三要素：封裝、繼承（或組合）、多態(tài)，前兩者較好理解，多態(tài)總讓人困惑，不知道具體有什么作用，更不知道為什么要用多態(tài)。今天就來詳細(xì)分析下什么是多態(tài)，以及多態(tài)有哪些好處，為什么要用多態(tài)？


多態(tài).png

多態(tài)是指同一行為作用于不同對象時，可以表現(xiàn)出多種不同的形式和結(jié)果來。例如，子類繼承父類并覆蓋其方法后，用父類引用指向子類對象并調(diào)用該方法時，實(shí)際執(zhí)行的是子類的方法。

這種根據(jù)對象實(shí)際類型而非聲明類型來確定執(zhí)行方法的行為，就是多態(tài)性的體現(xiàn)。多態(tài)主要通過繼承和接口實(shí)現(xiàn)，允許同一接口有多種不同的實(shí)現(xiàn)方式。

多態(tài)的分類

  • 編譯時多態(tài)，又稱靜態(tài)綁定，是指編譯器在編譯時通過檢查引用類型的方法是否存在，來定位到相應(yīng)的類及其方法，而不檢查實(shí)際對象是否支持該方法。編譯時多態(tài)主要體現(xiàn)在方法重載上，即根據(jù)參數(shù)類型、數(shù)量和順序，在編譯時確定要執(zhí)行的方法。

  • 運(yùn)行時多態(tài)，又稱動態(tài)綁定，是指程序在運(yùn)行時根據(jù)對象的實(shí)際類型來確定調(diào)用哪個方法，而不是在編譯時確定。這意味著方法的具體實(shí)現(xiàn)取決于對象的實(shí)際類型，而非其聲明類型。父類引用可以指向不同的子類對象，使得相同方法調(diào)用產(chǎn)生不同的行為結(jié)果。通過運(yùn)行時確定具體執(zhí)行的方法，代碼具有更好的擴(kuò)展性和可維護(hù)性。

多態(tài)的實(shí)現(xiàn)方式

編譯時多態(tài)，方法重載（Overloading）：

重載指在同一個類中可以有多個方法，這些方法名稱相同但參數(shù)列表不同（參數(shù)數(shù)量或類型不同）。

編譯器在編譯階段就能確定具體的方法。以下是一個重載示例，展示了多個同名方法，但參數(shù)個數(shù)或類型不同。重載的好處是簡化接口設(shè)計(jì)，不需要為不同類型編寫多個方法名。

// OverloadExample.java  全部源碼見文檔鏈接
/**
 * 重載示例，同名方法，參數(shù)個數(shù)或類型不同。
 * 編譯器在編譯時確定具體的調(diào)用方法。
 */
class Calculator {
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    public int add(int... nums) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        return sum;
    }
}

運(yùn)行時多態(tài)，方法重寫（Override）與轉(zhuǎn)型（Casting）：

運(yùn)行時多態(tài)是在程序運(yùn)行時確定實(shí)際要執(zhí)行的方法。

當(dāng)子類繼承父類并覆蓋同名方法時，這稱為重寫。使用父類引用來聲明子類對象時，子類會向上轉(zhuǎn)型為父類類型。調(diào)用該對象的方法時，實(shí)際執(zhí)行的是子類的方法，而不是父類的方法。

向上轉(zhuǎn)型是指使用父類引用聲明子類對象，使子類對象的實(shí)際類型變?yōu)楦割?。通過父類引用調(diào)用子類的方法，使代碼更加通用，處理一組相關(guān)對象時無需知道它們的具體類型。

向下轉(zhuǎn)型則是將父類引用轉(zhuǎn)換為子類引用，這需要顯式進(jìn)行，并且在轉(zhuǎn)換前需要使用 instanceof 關(guān)鍵字進(jìn)行類型檢查。

// OverrideExample.java 全部源碼見文檔鏈接
/**
 * 重寫示例，子類覆蓋父類同名方法，體現(xiàn)多態(tài)。
 * 子類向上轉(zhuǎn)型為父類型，父類強(qiáng)制向下轉(zhuǎn)型為子類型。
 */
class Shape {
  void draw() {
    System.out.println("Shape->draw");
  }

  void drawShape() {
    System.out.println("Shape->drawShape");
  }
}

class Circle extends Shape {
  @Override
  void draw() {
    System.out.println("Circle->draw");
  }

  void drawCircle() {
    System.out.println("Circle->drawCircle");
  }
}

class Square extends Shape {
  @Override
  void draw() {
    System.out.println("Square->draw");
  }

  void drawSquare() {
    System.out.println("Square->drawSquare");
  }
}

public class OverrideExample {
  public static void main(String[] args) {
    // 用父類引用聲明子類對象，向上轉(zhuǎn)型
    Shape shape1 = new Circle();
    Shape shape2 = new Square();

    // 子類有同名方法，動態(tài)綁定到子類，實(shí)質(zhì)執(zhí)行的是Circle.draw()，體現(xiàn)多態(tài)
    shape1.draw();

    // 報(bào)錯，編譯時按聲明類型檢查，Shape類中沒有drawCircle方法
    // shape1.drawCircle();

    // 執(zhí)行父類方法，輸出 "Shape->drawShape"
    shape1.drawShape();

    if (shape2 instanceof Square) {
      // 向下轉(zhuǎn)型，用子類重新聲明，成為子類型了
      Square mySquare = (Square) shape2;

      // 輸出 "Square->draw"
      mySquare.draw();

      // 輸出 "Square->drawSquare"
      mySquare.drawSquare();

      // 報(bào)錯。若強(qiáng)轉(zhuǎn)為父類型，則無法調(diào)用drawSquare方法
      // ((Shape) mySquare).drawSquare();

      // 繼承父類，輸出 "Shape->drawShape"
      mySquare.drawShape();
    }
  }
}

多態(tài)三個必要條件：

嚴(yán)格來說，多態(tài)需要具備以下三個條件。
繼承：子類繼承父類或?qū)崿F(xiàn)接口。
重寫：子類覆蓋父類的方法。
父類聲明子類：使用父類引用來聲明子類對象。
重載不屬于嚴(yán)格意義上的多態(tài)，因?yàn)橹剌d在編譯階段就確定了。這里主要探討運(yùn)行時的多態(tài)，即針對某個類型的方法調(diào)用，取決于運(yùn)行時的對象，而不是聲明時的類型。

// 父類
class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子類繼承并重寫同名方法
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Test {
    public static void main(String[] args) {
         // 父類引用聲明子類
        Animal myAnimal = new Dog();
         // 運(yùn)行時對象為子類，故輸出"Dog barks"
        myAnimal.makeSound();
    }
}

如何理解父類聲明子類 Parent child = new Child(); ？

  • 解釋：用 Parent 類聲明了一個 child 引用變量（變量存于棧中），并賦值為 Child 實(shí)例對象（對象存于堆中）。變量 child 的類型為 Parent（向上轉(zhuǎn)型），它的值是一個 Child 類型的實(shí)例對象。

  • 加載執(zhí)行順序：
    編譯時：JVM 編譯時檢查類的關(guān)系和對應(yīng)方法（包括重載），確定變量的類型并定位相關(guān)方法名稱，生成字節(jié)碼。
    運(yùn)行時：

    1. JVM 加載 Parent 和 Child 類。
    2. 根據(jù) Parent 和 Child 的大小分配堆內(nèi)存。
    3. 初始化 new Child() 并返回對象引用。
    4. 分配棧內(nèi)存給變量 child。
    5. 將對象引用賦值給 child。

  • 總結(jié)：
    編譯時根據(jù)引用類型（不是實(shí)例對象）確定方法的名稱和參數(shù)（包括重載）。
    運(yùn)行時如果子類覆蓋了父類的方法，則調(diào)用子類（實(shí)例引用類型）的方法；如果沒有覆蓋，則執(zhí)行父類（變量引用類型）的方法。

多態(tài)的好處，為什么要用多態(tài)？

在面向?qū)ο笤O(shè)計(jì)中，“開閉原則”是非常重要的一條。即系統(tǒng)中的類應(yīng)該對擴(kuò)展開放，而對修改關(guān)閉。這樣的代碼更可維護(hù)和可擴(kuò)展，同時更加簡潔與清晰。

延續(xù)上面的例子，假設(shè)業(yè)務(wù)需要擴(kuò)充更多子類，我們可以通過以下步驟來體現(xiàn)開閉原則：

  1. 新增子類：根據(jù)業(yè)務(wù)需求，新增符合現(xiàn)有類層次結(jié)構(gòu)的子類，例如增加AnotherChild。

  2. 繼承和重寫：新的子類應(yīng)該繼承自適當(dāng)?shù)母割悾⒏鶕?jù)需要重寫父類的方法或添加新的方法。

  3. 不需要修改現(xiàn)有的代碼：遵循開閉原則，我們不修改現(xiàn)有的 Parent 和 Child 類的代碼。

  4. 使用多態(tài)：通過父類引用來聲明子類，例如 Parent child = new AnotherChild();，這樣代碼中現(xiàn)有的邏輯不需要改變。

  5. 編譯時不變性：編譯時確定方法調(diào)用的特性不改變，仍然根據(jù)引用類型來確定方法的名稱和參數(shù)，子類隨意增加，只要覆蓋父類同名方法即可。

  6. 運(yùn)行時多態(tài)性：運(yùn)行時根據(jù)實(shí)際對象的類型來決定要執(zhí)行的方法，這使得代碼具有良好的可擴(kuò)展性和可維護(hù)性。

// 定義一個通用Animal類
class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 定義Dog類，它是動物的子類
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

// 定義Cat類，它是動物的子類
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }

    // Cat自有方法
    void meow() {
        System.out.println("Cat is meowing...");
    }
}

// 定義一個動物園類，管理不同的動物
class Zoo {
    // 傳入的是抽象父類或接口，方便擴(kuò)展
    void letAnimalMakeSound(Animal animal) {
        animal.makeSound();
    }
}

public class AnimalExample {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();

        Animal myDog = new Dog(); // 向上轉(zhuǎn)型
        Animal myCat = new Cat(); // 向上轉(zhuǎn)型
        ((Cat)myCat).meow(); // 向下強(qiáng)轉(zhuǎn)，打印自有方法

        // 通過多態(tài)性，動物園可以使用相同的方法處理不同種類的動物
        zoo.letAnimalMakeSound(myDog); // 輸出 "Dog barks"
        zoo.letAnimalMakeSound(myCat); // 輸出 "Cat meows"
    }
}

要增加新的動物（如鳥類，Bird），只需擴(kuò)展 Animal 類，而無需修改現(xiàn)有 Zoo 類中的方法。

class Bird extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bird chirps");
    }
}

public class AnimalExample {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();

        Animal myDog = new Dog(); // 向上轉(zhuǎn)型
        Animal myCat = new Cat(); // 向上轉(zhuǎn)型
        Animal myBird = new Bird(); // 向上轉(zhuǎn)型

        // 通過多態(tài)性，動物園可以使用相同的方法處理不同種類的動物
        zoo.letAnimalMakeSound(myDog); // 輸出 "Dog barks"
        zoo.letAnimalMakeSound(myCat); // 輸出 "Cat meows"
        zoo.letAnimalMakeSound(myBird); // 輸出 "Bird chirps"
    }
}

這種設(shè)計(jì)：

  • 允許新增 Animal 的子類，保持對擴(kuò)展開放；
  • 無需修改依賴 Zoo 的 letAnimalMakeSound 方法，實(shí)現(xiàn)對修改封閉。

我們的業(yè)務(wù)總在不停變化，如何使得代碼底層不用大概，而表層又能跟隨業(yè)務(wù)不停變動，這就顯得十分重要。通過這種方式，我們在不修改現(xiàn)有代碼的情況下，可以輕松地引入新的子類并擴(kuò)展系統(tǒng)功能，同時保持現(xiàn)有代碼的穩(wěn)定性和可靠性。

其他語言如何實(shí)現(xiàn)多態(tài)？

不同語言因?yàn)檎Z言特性的不同，在實(shí)現(xiàn)多態(tài)上也略有不同。不過總的概念是一致的，即達(dá)到“開閉原則”的目標(biāo)。以下一些語言的例子，其他例子請從倉庫查找源碼。

Go語言例子

在Go語言中，雖然沒有傳統(tǒng)意義上的類繼承、父類聲明子類和方法重載，但通過結(jié)構(gòu)體（struct）和接口（interface）以及匿名組合等方式實(shí)現(xiàn)類似的功能。這樣也能實(shí)現(xiàn)代碼的組織和復(fù)用，同時保持了靈活性和簡潔性。

package main

import (
  "fmt"
)

// 定義一個Animal接口
type Animal interface {
  MakeSound()
}

// 定義一個 Dog 類型
type Dog struct{}

// 實(shí)現(xiàn) Animal 接口的 MakeSound 方法
func (d Dog) MakeSound() {
  fmt.Println("Dog barks")
}

// 定義一個 Cat 類型
type Cat struct{}

// 實(shí)現(xiàn) Animal 接口的 MakeSound 方法
func (c Cat) MakeSound() {
  fmt.Println("Cat meows")
}

// Cat自有方法
func (c *Cat) Meow() {
  fmt.Println("Cat is meowing...")
}

// 定義一個 Zoo 類型，用于管理動物
type Zoo struct{}

// 定義一個方法，讓動物發(fā)出聲音
func (z Zoo) LetAnimalMakeSound(a Animal) {
  a.MakeSound()
}

func main() {
  zoo := Zoo{}
  myDog := Dog{}
  // 接口斷言
  var myCat Animal = &Cat{}
  // 類型斷言，打印自有方法
  (myCat.(*Cat)).Meow()

  // 使用多態(tài)性，通過接口類型處理不同的具體類型
  zoo.LetAnimalMakeSound(myDog) // 輸出 "Dog barks"
  zoo.LetAnimalMakeSound(myCat) // 輸出 "Cat meows"
}

當(dāng)需要增加Bird類型時，直接增加即可。同樣無需修改Zoo類里面的LetAnimalMakeSound方法。

type Bird struct{}

// 實(shí)現(xiàn) Animal 接口的 MakeSound 方法
func (b Bird) MakeSound() {
    fmt.Println("Bird chirps")
}

func main() {
  zoo := Zoo{}
  myDog := Dog{}
  var myCat Animal = &Cat{}
  (myCat.(*Cat)).Meow()
  myBird := Bird{}

  // 使用多態(tài)性，通過接口類型處理不同的具體類型
  zoo.LetAnimalMakeSound(myDog)  // 輸出 "Dog barks"
  zoo.LetAnimalMakeSound(myCat)  // 輸出 "Cat meows"
  zoo.LetAnimalMakeSound(myBird) // 輸出 "Bird chirps"
}

嚴(yán)格的多態(tài)概念，包括子類繼承父類、方法重寫以及父類聲明子類等，這些特性在Go語言中無法實(shí)現(xiàn)。Go語言沒有class概念，雖然它的struct可以包含方法，看起來像class，但實(shí)際上沒有繼承和重載的支持，它們本質(zhì)上仍是結(jié)構(gòu)體。

Go語言摒棄了傳統(tǒng)面向?qū)ο笳Z言中的class和繼承概念，我們需要用新的視角來理解和實(shí)踐面向?qū)ο缶幊淘贕o中的應(yīng)用方式

JavaScript語言例子

JavaScript是一種動態(tài)弱類型的基于對象的語言，其一切皆是對象。它通過對象的原型鏈來實(shí)現(xiàn)面向?qū)ο缶幊?。盡管JavaScript具有class和繼承的能力，但由于缺少強(qiáng)類型系統(tǒng)，因此無法實(shí)現(xiàn)傳統(tǒng)意義上的多態(tài)。

當(dāng)然，JavaScript作為動態(tài)語言，具有天然的動態(tài)性優(yōu)勢。這使得它在靈活性和擴(kuò)展性方面更具優(yōu)勢。

// 定義一個通用Animal類
class Animal {
    makeSound() {
        console.log("Animal makes a sound");
    }
}

// 定義Dog類，它是動物的子類
class Dog extends Animal {
    makeSound() {
        console.log("Dog barks");
    }
}

// 定義Cat類，它是動物的子類
class Cat extends Animal {
    makeSound() {
        console.log("Cat meows");
    }
    // Cat自有函數(shù)
    meow() {
        console.log("Cat is meowing...", this);
    }
}

// 定義一個動物園類，管理不同的動物
class Zoo {
    // JS沒有嚴(yán)格類型，出原始數(shù)據(jù)類型外，其他均是Object
    // 說出傳入的對象只要有makeSound方法即可。
    letAnimalMakeSound(animal) {
        animal.makeSound();
    }
}

// 測試代碼
const zoo = new Zoo();
// JS沒有父類定義子類概念，直接聲明即可，無需向上轉(zhuǎn)型
// 通過instanceof類型判斷時可得到子類和父類類型
const myDog = new Dog();
const myCat = new Cat();

// 直接調(diào)用自有函數(shù)
myCat.meow();

// 可以動態(tài)給對象設(shè)置函數(shù)并綁定對象 
myDog.meow = myCat.meow.bind(myDog); 
myDog.meow();

// 動物園可以使用相同的方法處理不同種類的動物
// 當(dāng)需要增加其他動物時，直接建立新的類繼承Animal，而無需修改Zoo。
zoo.letAnimalMakeSound(myDog); // 輸出 "Dog barks"
zoo.letAnimalMakeSound(myCat); // 輸出 "Cat meows"

可以看出JS要實(shí)現(xiàn)Java意義的多態(tài)是做不到的，但JavaScript更加靈活方便，聲明對象無需類型，還可以動態(tài)添加函數(shù)和綁定對象。

Python語言例子

# 定義一個通用Animal類  
class Animal:  
    def make_sound(self):  
        print("Animal makes a sound")  
  
# 定義Dog類，繼承Animal
class Dog(Animal):  
    name = "Dog"
    def make_sound(self):  
        print("Dog barks")  
  
# 定義Cat類，繼承Animal
class Cat(Animal):  
    name = "Cat"
    def make_sound(self):  
        print("Cat meows")  
  
    # Cat自有方法  
    def meow(self):  
        print(self.name + " is meowing...")  
  
# 定義Bird類，它是動物的子類  
class Bird(Animal):  
    def make_sound(self):  
        print("Bird chirps")  

# 定義管理類
class Zoo:  
    # python與js一樣為動態(tài)語言，使用duck typing，不需要顯式聲明接口
    def let_animal_make_sound(self, animal):  
        animal.make_sound()  
  
# 測試代碼
if __name__ == "__main__":
    zoo = Zoo()

    # 直接創(chuàng)建實(shí)例，Python中不需要向上轉(zhuǎn)型
    my_dog = Dog()
    my_cat = Cat()
    my_bird = Bird()

    # 直接調(diào)用自有方法
    my_cat.meow()

    # Python中可直接給對象設(shè)置方法，self不會改變
    my_dog.meow = my_cat.meow
    my_dog.meow()

    # 動物園可以使用相同的方法處理不同種類的動物
    zoo.let_animal_make_sound(my_dog)  # 輸出 "Dog barks"
    zoo.let_animal_make_sound(my_cat)  # 輸出 "Cat meows"
    zoo.let_animal_make_sound(my_bird)  # 輸出 "Bird chirps"

Python是一種動態(tài)語言，它使用 self 參數(shù)來引用實(shí)例，無需像其他語言那樣使用 new 關(guān)鍵字來實(shí)例化對象。Python沒有嚴(yán)格的接口概念，不需要像其他語言那樣顯示聲明對象的接口。Python通過繼承和方法重寫來實(shí)現(xiàn)多態(tài)概念，但不支持傳統(tǒng)意義上的父類聲明子類和方法重載。

因此，Python在多態(tài)性上的表現(xiàn)與JavaScript相似，都是基于動態(tài)語言特性，靈活而動態(tài)，通過繼承和重寫實(shí)現(xiàn)對象行為的多樣性。

Java多態(tài)實(shí)例詳解

理解Java多態(tài)的實(shí)例可以幫助澄清其原理和執(zhí)行過程。以下是一個簡單而詳盡的例子，幫助你全面理解Java中多態(tài)的工作機(jī)制。

// PolymorphismSimple.java
// 父類A
class A {
    public String show(D object) {
        return ("A and D");
    }

    public String show(A object) {
        return ("A and A");
    }

    // 默認(rèn)注釋掉?？砷_關(guān)注釋測試下
    // public String show(B object) {
    // return ("A and B");
    // }
}

// 子類B
class B extends A {
    public String show(B object) {
        return ("B and B");
    }

    public String show(A object) {
        return ("B and A");
    }
}

// 孫子類C
class C extends B {
}

// 孫子類D
class D extends B {
}

// 測試驗(yàn)證
public class PolymorphismSimple {
    public static void main(String[] args) {
        // 父類聲明自己
        A a = new A();
        // 父類聲明子類
        A ab = new B();
        // 子類聲明自己
        B b = new B();
        C c = new C();
        D d = new D();

        // 1) A and A。b的類型是B，也是B的實(shí)例，A里沒有show(B)方法，但有show(A)方法。B的父類是A，因此定位到A.show(A)。
        System.out.println("1) " + a.show(b));

        // 2) A and A。c的類型是C，也是C的實(shí)例，C繼承B，B繼承A。A里沒有show(C)方法，也沒有show(B)方法，最后指向A.show(A)。
        System.out.println("2) " + a.show(c));

        // 3) A and D, d的類型是D，也是D的實(shí)例，D繼承B，B繼承A。A里有show(D)方法，直接定位到A.show(D)。
        System.out.println("3) " + a.show(d));

        // 4) B and A, ab是B的實(shí)例，但用A聲明，即向上轉(zhuǎn)型得到的類型是A，運(yùn)行時才能確定具體該調(diào)用哪個方法。
        // ab是B的實(shí)例對象，但引用類型是A。類型是在編譯時確定，因此從類型開始定位方法。
        // A類中沒有show(B)方法，但有show(A)方法，因?yàn)锳是B的父類，ab也是A的實(shí)例，于是定位到A.show(A)方法。
        // 由于B是A的子類，且B重寫了A的show(A)，A的方法被覆蓋了，于是定位到B.show(A)，這就是動態(tài)綁定。
        // 雖然B中有show(B)方法，但是因?yàn)閍b的類型是A，編譯時根據(jù)類型定位到A的方法，而不是B。

        // 以下幾種可開關(guān)打開/注釋代碼測試下。
        // -
        // 若A里有show(A)和show(B)，B里有show(B)有show(A)，則編譯時關(guān)聯(lián)到A.show(B)，因B覆蓋了A.show(B)，動態(tài)綁定到B.show(B)。
        // -
        // 若A里有show(A)和show(B)，B里無show(B)有show(A)，則編譯時關(guān)聯(lián)到A.show(B)，因B無覆蓋，則直接調(diào)用A.show(B)。
        // -
        // 若A里有show(A)無show(B)，B里無show(B)有show(A)，則編譯時關(guān)聯(lián)到A.show(A)，因B覆蓋了A.show(A)，動態(tài)綁定到B.show(A)。
        // -
        // 若A里有show(A)無show(B)，B里無show(A)有show(B)，則編譯時關(guān)聯(lián)到A.show(A)，因B無覆蓋，則直接調(diào)用A.show(A)。
        // 查找順序?yàn)椋壕幾g時根據(jù)引用類型確定所屬類 -> 根據(jù)重載參數(shù)類型定位（類型按子->父->祖逐級往上查找）到類的具體方法（包括繼承的方法） ->
        // 運(yùn)行時實(shí)例對象覆蓋（覆蓋只有子->父一層）了引用類型的同名方法 -> 定位到實(shí)例對象的方法。
        System.out.println("4) " + ab.show(b));

        // 5) B and A。ab是B的實(shí)例，類型是A。從A類沒找到show(C)方法，也沒找到A.show(B)方法，找到A.show(A)方法。A.show(A)被B.show(A)覆蓋，因此調(diào)用B.show(A)。
        System.out.println("5) " + ab.show(c));

        // 6) A and D。A里面有show(D)的方法，直接定位到。
        System.out.println("6) " + ab.show(d));

        // 7) B and B。B里面有show(B)的方法，直接定位到。
        System.out.println("7) " + b.show(b));

        // 8) B and B。B沒有show(c)方法，但有show(B)方法。C繼承自B，父類型是B，因此調(diào)用B.show(B)。
        System.out.println("8) " + b.show(c));

        // 9) A and D。B中沒有show(D)方法，B繼承A，A里有show(D), 故調(diào)用A.show(D)方法。
        System.out.println("9) " + b.show(d));

        // 10) B and A。父類聲明子類，存在向上轉(zhuǎn)型。A里有show(A)，被B.show(A)覆蓋了，因此定位到B.show(A)。
        System.out.println("10) " + ab.show(a));

    }
}

總結(jié)

多態(tài)包括編譯時多態(tài)和運(yùn)行時多態(tài)。編譯時多態(tài)，即靜態(tài)綁定，通常通過方法重載實(shí)現(xiàn)。運(yùn)行時多態(tài)則是在代碼運(yùn)行時確定具體調(diào)用的方法。

從Java的角度看，嚴(yán)格意義上的多態(tài)需要滿足三個條件：繼承、方法覆蓋和父類引用子類對象。Java完全符合這些要求，實(shí)現(xiàn)了嚴(yán)格意義上的多態(tài)。

Go語言、Python和JavaScript不完全符合嚴(yán)格意義上的多態(tài)，但具備多態(tài)特性，能夠達(dá)成動態(tài)確定實(shí)際要執(zhí)行的方法，從而使代碼更加靈活、易于維護(hù)和擴(kuò)展。

各語言完整示例

https://github.com/microwind/design-pattern/tree/main/programming-paradigm/oop/polymorphism

簡單示例

PolymorphismSimple.java
PolymorphismSimple.go
polymorphism_simple.c
PolymorphismSimple.cpp
PolymorphismSimple.js
PolymorphismSimple.py
PolymorphismSimple.ts

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容