Java中多型

阿新 • • 發佈：2021-07-09

1.1 多型的概述及其程式碼體現

* A：多型（polymorphic)概述

* 事物存在的多種形態

* B:多型的前提

* a:要有繼承關係

* b:要有方法重寫。

* c:要有父類引用指向子類物件。

程式碼：

public class Demo01_Polymorphic {
    public static void main(String[] args) {
        Cat cat = new Cat();   // new Cat()是一個物件，小貓是一隻貓
        cat.eat();

        Animal animal = new Cat(); // 父類引用指向子類物件，子類即父類 

        animal.eat();
    }
}

//基本類
class Animal{
    public void eat(){
        System.out.println("動物吃飯");
    }
}

// 貓類繼承了動物類
class Cat extends Animal{
    // 重寫了父類方法
    public void eat(){
        System.out.println("貓吃魚");
    }
}

1.2多型中成員方法的特點

1.2.1 成員變數

A：多型中成員訪問的特點

* a:成員變數

* 編譯看左邊（父類），執行看左邊（父類）。

程式碼：

public class Demo02_Polymorphic { 

    public static void main(String[] args) {
        Father f = new Son();     // 父類引用指向子類物件                                 
        System.out.println(f.num);       //10 f是Father型別的，只能看到father那一塊輸出的結果是10
        Son son = new Son();
        System.out.println(son.num);
    }
}
// 父類
class Father{
    int num = 10;
} 


// 繼承父類
class Son extends Father{
    int num = 20;
}

記憶體圖：

1.2.2 成員方法

A：多型中成員訪問的特點

* a:成員方法

* 編譯看左邊（父類），執行看右邊（子類）。(只有這一種情況是真正的多型）

1.2.3 靜態方法

A：多型中成員訪問的特點

* a:靜態方法

* 編譯看左邊（父類），執行看左邊（子類）。

程式碼：

public class Demo02_Polymorphic {
    public static void main(String[] args) {
        Father f = new Son();     // 父類引用指向子類物件  f是Father型別 int a
        f.show();           // 成員方法的動態繫結
    }
}
// 父類
class Father{
    int num = 10;
    public static void show(){
        System.out.println("Father static 父類");
    }
}

// 繼承父類
class Son extends Father{
    int num = 20;
    // 子類重寫了父類的方法
    public static void show(){
        System.out.println("Son staitc 子類");
    }
}

1.3 多型中向上轉型和向下轉型

A：案例演示
*詳細講解多型中向上轉型和向下轉型
*Person p = new SuperMan();向上轉型
*SuperMan sm = (SuperMan)p;向下轉型

程式碼：

/**
 * A：案例演示
 *     * 詳細講解多型中向上轉型和向下轉型
 *     * Person p = new SuperMan(); 向上轉型
 *     * SuperMan sm = (SuperMan)p;向下轉型
 */
public class Demo03_Polymorphic {
    public static void main(String[] args) {
        Person p = new SuperMan();   // 父類引用指向子類物件
        p.business();
        // p.fly();    // 超人所具有特性  父類的物件無法使用子類的特有方法

        SuperMan s1 = (SuperMan)p;     // int i = (int)5.0;
        s1.fly();  //  這時候可以呼叫子類的特有方法
    }
}

class Person{
    String name = "John";
    public void business() {
        System.out.println("談生意");
    }
}

class SuperMan extends Person{
    String name = "SuperMan";

    // 重寫了談生意的方法
    public void business() {
        System.out.println("談幾個億的大單");
    }
    // 特有的方法
    public void fly() {
        System.out.println("飛出去救人");
    }
}

1.4 多型的好處和弊端

* A：多型的好處

* a:提高了程式碼的維護性（繼承保證）

* b:提高了程式碼的擴充套件性（由多型保證）

* B:案例演示

* 多型的好處

* 可以當作形式引數，可以接收任意子類物件

* C：多型的弊端

* 不能使用子類的特有屬性和行為。

程式碼：

public class Demo01_Polymorphic {
    public static void main(String[] args) {
        Cat cat = new Cat();
        method(cat);         // 第一次呼叫時Animal a = cat{new Cat()};
        Dog dog = new Dog();
        method(dog);        // 第二次呼叫時Animal a = dog{new dog()};
        Pig pig = new Pig();// 第一次呼叫時Animal a = pig{new Pig()};
        method(pig);
    }

    public static void method(Animal a){   // 父類的引用指向子類物件
        a.eat();
    }
}

//基本類
class Animal{
    public void eat(){
        System.out.println("動物吃飯");
    }
}

// 貓類繼承了動物類
class Cat extends Animal{
    // 重寫了父類方法
    public void eat(){
        System.out.println("貓吃魚");
    }
}

class Dog extends Animal{
    // 重寫了父類方法
    public void eat(){
        System.out.println("狗吃骨頭");
    }
}

class Pig extends Animal{
    // 重寫了父類方法
    public void eat(){
        System.out.println("吃玉米");
    }
}