03.Java 基礎 - 多態

基本概念

多態是同一個行為具有多個不同表現或形態的能力。

多態性是物件多種表現形式的體現。

多態發生的條件 ：繼承、重寫、向轉型

#動態綁定是多型實作的具體形式。

---

實例探究

下面透過一個例子驗證上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}

觀察程式碼，在呼叫 Car 的 show 方法時列印了不同的內容，體現了類別的多態性。同時例子也滿足了發生多態的三個基本條件：

• 繼承：Toyota 、Buick 繼承自Car

• 重寫： Toyota 、Buick 重寫了Car 的show 方法

• 向轉型：建立 Toyota 、Buick 物件時發生向上轉型

---

再來看來一個典型題目：

class A {    public String show(A obj) {        return ("A and A");
    }    public String show(D obj) {        return ("A and D");
    }
}

class B extends A {    public String show(A obj) {        return ("B and A");
    }    public String show(B obj) {        return ("B and B");
    }
}

class C extends B {
}

class D extends B {
}public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A， 且 B 是 A 的子类，调用类 A 的 show(A obj) 方法
        // 但是由于 B 中重写了 show(A obj) 方法，导致运行期间发生的动态绑定，调用 类 B 的 show(A obj) 方法
        // ，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}

---

##建構子與多型

同樣的透過一個實例來探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 重写（override）了父类方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        /**
         * 输出内容： 
         * I am a Son 0
         * I am a Son 1
         */
    }
}

透過輸出內容我們可以看到，Parent 的建構器由於動態綁定，呼叫了Son 的print（），由於num 還未被初始化，導致了值為0。

基本概念

多型態是同一個行為具有多個不同表現或形態的能力。

多態性是物件多種表現形式的體現。

多態發生的條件 ：

繼承、重寫、向轉型

#動態綁定是多型實作的具體形式。

---

實例探究

下面透過一個範例驗證上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}

觀察程式碼，在呼叫 Car 的 show 方法時列印了不同的內容，體現了類別的多態性。同時例子也滿足了發生多態的三個基本條件：

• 繼承：Toyota 、Buick 繼承自Car

• 重寫： Toyota 、Buick 重寫了Car 的show 方法

• 向轉型：建立 Toyota 、Buick 物件時發生向上轉型

---

再來看來一個典型題目：

class A {    public String show(A obj) {        return ("A and A");
    }    public String show(D obj) {        return ("A and D");
    }
}

class B extends A {    public String show(A obj) {        return ("B and A");
    }    public String show(B obj) {        return ("B and B");
    }
}

class C extends B {
}

class D extends B {
}public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A，应该是调用类 A 的 show(A obj) 方法
        // 由于 B 中重写了 show(A obj) 方法，实际调用 类 B 的方法，，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}

---

##建構子與多型

同樣的透過一個實例來探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 关键 -> 重写了父类的方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        // 输出内容： 
        // I am a Son 0
        // I am a Son 1
    }
}

分析結果，其實它牽涉到了三個內容：

Son  在實例化的過程中，Parent  的建構函數， Parent  的建構函數先執行。
Son 重寫了 print 方法，因此 Parent 呼叫的是 Son 重寫後的方法。
在 Parent 由於 num 尚未初始化，因此值為 0。

基本概念

多型是同一個行為具有多個不同表現或形態的能力。

多態性是物件多種表現形式的體現。

多態發生的條件 ：

繼承、重寫、向轉型

#動態綁定

是多型實作的具體形式。

---

實例探究

下面透過一個例子驗證上面的概念。

// 车class Car {    public void show(){
        System.out.println("This is a car");
    }
}//丰田class Toyota extends Car{    public void show(){
        System.out.println("This is a Japan car");
    }
}//别克class Buick extends Car{    public void show(){
        System.out.println("This is a USA car");
    }
}public class Test{  
    public static void main(String[] args) {
        Car c1 = new Toyota();
        Car c2 = new Buick();
        c1.show();
        c2.show();        // 打印内容：
        // This is a Japan car
        // This is a USA car
    }
}

觀察程式碼，在呼叫 Car 的 show 方法時列印了不同的內容，體現了類別的多態性。同時例子也滿足了發生多態的三個基本條件：

• 繼承

  ：Toyota 、Buick 繼承自Car

• 重寫

  ： Toyota 、Buick 重寫了Car 的show 方法

• 向轉型

  ：建立 Toyota 、Buick 物件時發生向上轉型

再來看一個典型題目：

---

class A {    public String show(A obj) {        return ("A and A");
    }    public String show(D obj) {        return ("A and D");
    }
}

class B extends A {    public String show(A obj) {        return ("B and A");
    }    public String show(B obj) {        return ("B and B");
    }
}

class C extends B {
}

class D extends B {
}public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();        // 1.因此 B 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(b));        // 2.因为 C 是 A 的子类，调用类 A 的 show(A obj) 方法，输出：A and A
        System.out.println(a1.show(c));        // 3.调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a1.show(d));        // 4.因为 B 向上转型成 A， 且 B 是 A 的子类，调用类 A 的 show(A obj) 方法
        // 但是由于 B 中重写了 show(A obj) 方法，导致运行期间发生的动态绑定，调用 类 B 的 show(A obj) 方法
        // ，输出：B and A
        System.out.println(a2.show(b));        // 5.同上
        System.out.println(a2.show(c));        // 6.B 向上转型成 A，默认调用类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(a2.show(d));        // 7.调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(b));        // 8.C 是 B 的子类，调用类 B 的 show(B obj) 方法，输出：B and B
        System.out.println(b.show(c));        // 9.调用继承自类 A 的 show(D obj) 方法，输出：A and D
        System.out.println(b.show(d));

    }
}

##建構子與多型

---

同樣的透過一個實例來探究

class Parent {    void print() {
        System.out.println("I am a Parent");
    }

    Parent() {
        print();
    }
}

class Son extends Parent {    int num = 1;    // 重写（override）了父类方法
    void print() {
        System.out.println("I am a Son " + num);
    }

    Son() {
        print();
    }
}public class Test {
    public static void main(String[] args) {
        Son son = new Son();        /**
         * 输出内容： 
         * I am a Son 0
         * I am a Son 1
         */
    }
}

透過輸出內容我們可以看到，Parent 的建構器由於動態綁定，呼叫了Son 的print（），由於num 還未被初始化，導致了值為0。

分析結果，其實它牽涉到了三個內容：

Son  在實例化的過程中，Parent  的建構函數， Parent  的建構函數先執行。

• Son 重寫了 print 方法，因此 Parent 呼叫的是 Son 重寫後的方法。

• 在 Parent 由於 num 尚未初始化，因此值為 0。

•  以上就是03.Java 基礎 - 多型的內容，更多相關內容請關注PHP中文網（www.php.cn）！

#