後端開發 / ENGINEERING NOTES

Java 繼承、多型、抽象類別與介面:差在哪、該怎麼選

用 Java 範例說明繼承與多型(方法覆寫、以父類別參考呼叫子類別),並比較抽象類別與介面的特性與選擇。

JavaAbstract ClassInterface

Abstract Classes vs Interfaces in Java

Overview

本文件深入比較了 Java 中的抽象類別與介面,介紹了各自的特性、使用情境以及實作示例,方便您根據需求選擇合適的設計方法。

Abstract Classes

抽象類別可以同時包含抽象方法與實體方法,子類別可選擇性地覆寫抽象方法而不必覆寫實體方法。

Example

abstract class User {
    abstract void displayInfo();

    void greet() {
        System.out.println("Hello!");
    }
}

class AdminUser extends User {
    @Override
    void displayInfo() {
        System.out.println("Admin User");
    }
}

若子類別尚未覆寫所有抽象方法,則子類本身也必須聲明為抽象類別:

abstract class Ghost extends User {
    // 額外定義一個抽象方法
    abstract void haunt();
    // 無需覆寫 greet() 方法
}

Main 方法示例

public class Main {
    public static void main(String[] args) {
        AdminUser admin = new AdminUser();
        admin.greet();        // 輸出: Hello!
        admin.displayInfo();  // 輸出: Admin User
    }
}

Interfaces

介面定義了一組合約,各個類別通過實作介面來提供具體行為。自 Java 8 以後,介面也支援 default 方法,允許直接在介面中定義預設實作。

Example

interface Walker {
    void walk();

    default void breathe() {
        System.out.println("Breathing...");
    }
}

實作介面的類別:

class Human implements Walker {
    // 可視需求覆寫 walk() 方法
}

class Dog implements Walker {
    @Override
    public void walk() {
        System.out.println("Dog is walking");
    }
}

public class Main {
    public static void main(String[] args) {
        Human human = new Human();
        human.walk();    // 使用介面預設或自行實作
        human.breathe(); // 輸出: Breathing...

        Dog dog = new Dog();
        dog.walk();      // 輸出: Dog is walking
    }
}

Inheritance and Polymorphism

利用抽象類別實現多型

抽象類別允許子類別共享通用行為並覆寫專屬功能:

abstract class Animal {
  public abstract void makeSound(); // 抽象方法

  public void eat() {
      System.out.println("The animal is eating");
  }
}

利用介面實現多重繼承

介面允許一個類別實作多個介面,從而組合多種行為:

interface AnimalMovement {
  void walk();
}

class Dog implements AnimalMovement {
  @Override
  public void walk(){
    System.out.println("Dog is walking");
  }
}

Java 繼承與多型:子類別覆寫方法與父類別參考變數呼叫

繼承 Inheritance

繼承父類別,在子類別使用其方法及屬性。

多型 Polymorphism

子類別覆寫父類別方法,改寫成適合子類別的方法,但方法名字維持相同,以對該方法抽象化。


直接實例化子類別以調用方法

先有繼承,才能使用多形。

創建一個實體類別 Animal。他有一個可以發出聲音的方法 makeSound。

public class Animal {
    public void makeSound() {
      System.out.println("Animal sound");
    };
}

用三個類別繼承他,兩個覆寫方法 makeSound,一個只繼承類別。

public class Cat extends Animal {
    @Override
    public void makeSound() {
      System.out.println("Meow!");
    }
}
public class Dog extends Animal {
    @Override
    public void makeSound() {
      System.out.println("Woof!");
    }
}
public class Human extends Animal {
    // 沒覆寫方法
}

實例化這三個子類別並呼叫 makeSound()。

public static void case1() {
    Cat cat = new Cat();
    Dog dog = new Dog();
    Human human = new Human();

    cat.makeSound();    // Meow!

    dog.makeSound();    // Woof!

    human.makeSound();  // Animal sound
}

Cat 與 Dog 使用了自己覆寫的 makeSound(),而 Human 使用了父類別的 makeSound()。如果子類別沒有覆寫父類別的方法,則子類別將繼承父類別的方法。

多型:實例化子類別,以父類別做參用變量調用方法
public static void case2() {
    Cat cat = new Cat();
    Dog dog = new Dog();
    Human human = new Human();

    Animal animal; // 以父類別做參用變量

    animal = cat;
    animal.makeSound(); // Meow!

    animal = dog;
    animal.makeSound(); // Woof!

    animal = human;
    animal.makeSound(); // Animal sound
}

當需要新增加其他子類別時,無需修改現有的程式碼,只需要新增新的子類別並確保它們符合父類別的方法。 符合開閉原則 OCP。

實現多型的範例
interface A {
    void getValue();
}

interface B extends A {
    @Override
    default void getValue() {
        System.out.println(1);
    }
}

class C implements B {
    // 有實現多型,只要用非C class來實例化與呼叫方法就算
    public void add(A a) { a.getValue(); }
    public void add(B b) { b.getValue(); }
    public void add(A a, B b) { a.getValue(); b.getValue(); }
    // 沒實現多型
    public void add(C c) { c.getValue(); }
    public void add(C c1, C c2) { c1.getValue(); }
}

因為 A 是一個介面,所以任何實作了 A 介面的類別的物件都可以傳遞給 add 方法。

TY的智慧庫

你有事?
問前想清楚,機會不是誰都有。

💡 建議主題:

放大圖片