後端開發 / ENGINEERING NOTES
Java 繼承、多型、抽象類別與介面:差在哪、該怎麼選
用 Java 範例說明繼承與多型(方法覆寫、以父類別參考呼叫子類別),並比較抽象類別與介面的特性與選擇。
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 方法。