您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 相關知識

Java 抽象類別與介面差異深度解析 (語法與設計層面)

編輯：Java 相關知識

核心定義

特性	抽象類別 (abstract class)	介面 (interface)
關鍵字	`abstract class`	`interface`
核心目的	對事物的抽象 (is-a 關係)	對行為/契約的抽象 (can-do 關係)
方法類型	抽象方法 + 具體方法 + 靜態方法	Java 7-: 僅抽象方法 Java 8+: default/private/靜態方法
成員變數	任意修飾符、任意類型	隱含 `public static final` (常量)
建構子	可有 (供子類呼叫)	不可有
繼承/實作	單一繼承 (extends 一個)	多重實作 (implements 多個)
存取修飾符	方法可為 public/protected/private	方法隱含 public (Java 8+ private 除外)

語法層面詳細比較

1. 方法定義差異

// 抽象類別：可混合抽象與具體方法
abstract class Animal {
    // 抽象方法：強制子類實作
    public abstract void makeSound();
    
    // 具體方法：提供預設實作，子類可選擇覆寫
    public void breathe() {
        System.out.println("呼吸中...");
    }
    
    // 受保護方法：僅子類可見
    protected void internalLogic() {}
    
    // 靜態方法：屬於類別
    public static void staticMethod() {}
    
    // Java 8+ 也可有 default 方法 (但較少用)
    public default void defaultMethod() {}
}

// 介面：Java 8 前僅抽象方法，Java 8+ 可有 default/static/private
interface Flyable {
    // 隱含 public abstract
    void fly(); 
    
    // Java 8+ 預設實作 (不強制實作)
    default void hover() {
        System.out.println("懸停飛行");
    }
    
    // Java 8+ 靜態方法
    static void staticFly() {
        System.out.println("靜態飛行");
    }
    
    // Java 9+ 私有方法 (供 default 方法複用)
    private void helper() {}
    
    // 成員變數隱含 public static final
    int MAX_HEIGHT = 10000; // 等同 public static final int MAX_HEIGHT = 10000;
}

2. 繼承/實作語法

// 單一繼承抽象類別，可多重實作介面
class Bird extends Animal implements Flyable, Serializable {
    @Override
    public void makeSound() { System.out.println("啾啾~"); }
    
    @Override
    public void fly() { System.out.println("鳥兒飛"); }
    
    // 可選擇覆寫 default 方法
    @Override
    public void hover() { System.out.println("鳥兒懸停"); }
}

// 介面可多重繼承 (extends 多個介面)
interface Swimmable extends Flyable, Serializable {
    void swim();
}

3. 成員變數差異示範

abstract class Base {
    public int publicVar = 1;
    protected int protectedVar = 2;
    private int privateVar = 3;
    static int staticVar = 4;
    final int finalVar = 5; // 實例常量
}

interface Constants {
    int API_VERSION = 1;           // public static final int API_VERSION = 1;
    String DEFAULT_ENCODING = "UTF-8"; // public static final String...
    // 無法定義實例變數、非 final 變數、私有變數
}

設計層面核心差異

抽象類別：模板模式的載體

語意：定義一族相關類別的共同骨架，封裝共同屬性與邏輯
適用：強相關類別、需要共享代碼/狀態、定義演算法骨架 (Template Method Pattern)
例子：AbstractList、HttpServlet、JpaRepository 基類

介面：契約與多型的基石

語意：定義行為契約，規範「能做什麼」，不關心「怎麼做」
適用：跨領域能力、解耦合、多型替換、SPI 擴展點、函數式介面
例子：Runnable、Comparable、Serializable、List、JDBC Driver

經典設計決策指南

場景	選擇	理由
需要提供預設實作供複用	抽象類別 (或 Java 8+ interface default)	避免重複代碼，集中維護
定義跨層級、無關類別的共同能力	介面	如 Serializable、Cloneable、Comparable
需要實例變數/狀態	抽象類別	介面無實例狀態
需要建構子初始化	抽象類別	介面無建構子
單一繼承限制衝突	介面	類別只能 extends 一個
API 公開給第三方實作	介面	契約穩定，實作自由度高
演算法骨架固定，部分步驟可變	抽象類別 (Template Method)	定義流程，延遲具體實作
函數式編程 (Lambda)	函數式介面 (單一抽象方法)	Java 8+ Lambda 語法糖

Java 8+ 介面演進：模糊邊界

interface ModernInterface {
    // 1. 預設方法：提供實作，不破壞現有實作類
    default void log(String msg) {
        System.out.println("[LOG] " + msg);
    }
    
    // 2. 靜態方法：工具方法，屬於介面
    static String format(String msg) {
        return ">> " + msg + " <<";
    }
    
    // 3. 私有方法：default 方法間複用邏輯 (Java 9+)
    private void internalHelper() {}
    
    // 核心契約：仍需實作
    void execute();
}

// 實作類可選擇覆寫 default 方法
class Impl implements ModernInterface {
    @Override
    public void execute() {
        log("執行中..."); // 直接使用 default 方法
    }
}

影響：介面現在也能提供代碼複用，但設計意圖仍不同：介面定義「能力」，抽象類別定義「骨架」。

實戰案例：集合框架設計

// 介面定義契約
interface Collection<E> extends Iterable<E> {
    int size();
    boolean add(E e);
    Iterator<E> iterator();
    // ... 核心契約
}

// 抽象類別提供骨架實作
abstract class AbstractCollection<E> implements Collection<E> {
    // 具體方法：基於抽象方法 iterator() 實作
    @Override
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c) {
            if (add(e)) modified = true;
        }
        return modified;
    }
    
    @Override
    public String toString() {
        Iterator<E> it = iterator();
        if (!it.hasNext()) return "[]";
        StringBuilder sb = new StringBuilder("[");
        while (true) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (!it.hasNext()) return sb.append("]").toString();
            sb.append(", ");
        }
    }
    // 留給子類實作的抽象方法
    public abstract Iterator<E> iterator();
    public abstract int size();
    public abstract boolean add(E e);
}

// 具體實作
class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    // ... 具體實作
}