抽象類與介面深度對比（三）：選型決策矩陣、設計模式應用與演進視角

核心異同速覽

何時選抽象類？決策清單

滿足任一核心條件 → 抽象類：

1. 需要共享代碼/狀態：多個子類有相同字段、相同邏輯實現（模板方法模式）。
2. 需要非 public 成員：protected 輔助方法、private 內部邏輯。
3. 需要構造器初始化：強制子類傳遞必要參數（如 DataSource、ThreadPool）。
4. 演進中保持二進制兼容：新增非抽象方法不破壞現有子類（介面新增方法需 default 或破壞實現類）。

經典模板方法模式

public abstract class AbstractParser {
    // 共享字段
    protected final Charset charset;
    
    // 構造器強制參數
    public AbstractParser(Charset charset) { this.charset = charset; }
    
    // 模板方法：定義算法骨架
    public final String parse(File file) throws IOException {
        String raw = readFile(file);           // 通用步驟
        String processed = preProcess(raw);    // 可變步驟
        return doParse(processed);             // 抽象步驟
    }
    
    // 具體方法（共享邏輯）
    private String readFile(File file) throws IOException {
        return Files.readString(file.toPath(), charset);
    }
    protected String preProcess(String raw) { return raw.trim(); } // 鉤子方法
    
    // 抽象方法（子類必須實現）
    protected abstract String doParse(String content);
}

// 子類只關注核心解析邏輯
public class JsonParser extends AbstractParser {
    public JsonParser() { super(StandardCharsets.UTF_8); }
    @Override protected String doParse(String content) {
        return new JSONObject(content).toString(2);
    }
}

何時選介面？決策清單

滿足任一核心條件 → 介面：

1. 多實現無關類之間的共同行為：Serializable, Comparable, Runnable（標記/能力介面）。
2. 類已繼承其他類：Java 單繼承限制，只能 implements。
3. 定義類型層次的邊界：API 邊界、SPI 擴展點、插件系統。
4. 需要多重組合：一個類同時具備 Serializable & Cloneable & Comparable。

介面隔離原則 (ISP) 實踐

// 臃腫介面 → 拆分
// Bad
interface Machine { void print(); void scan(); void fax(); }

// Good - 客戶只依賴需要的能力
interface Printable { void print(); }
interface Scannable { void scan(); }
interface Faxable { void fax(); }

// 組合實現
class MultiFunctionPrinter implements Printable, Scannable, Faxable { ... }
class SimplePrinter implements Printable { ... }

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

• default 方法：提供默認實現，不強制子類覆寫。解決介面擴展兼容性（Collection.stream()）。
• static 方法：工具方法歸屬介面（Comparator.naturalOrder()）。
• private 方法 (JDK 9+)：default 方法間共享邏輯。

菱形繼承衝突規則

interface A { default void foo() { System.out.println("A"); } }
interface B extends A { default void foo() { System.out.println("B"); } }
interface C extends A { default void foo() { System.out.println("C"); } }
class D implements B, C { 
    // 必須顯式覆寫解決衝突
    @Override public void foo() { B.super.foo(); } 
}

混合策略：骨架抽象類 + 能力介面

大型框架常見模式：

// 1. 定義能力介面（多實現、組合）
public interface EventListener { void onEvent(Event e); }
public interface Ordered { int getOrder(); }

// 2. 提供骨架抽象類（共享狀態、模板方法、通用邏輯）
public abstract class AbstractEventListener implements EventListener, Ordered {
    private final Logger log = LoggerFactory.getLogger(getClass());
    private int order = 0;
    
    public final void onEvent(Event e) {  // 最終模板
        log.debug("Processing {}", e);
        try { doHandle(e); }
        catch (Exception ex) { handleError(e, ex); }
    }
    protected abstract void doHandle(Event e);  // 核心變化點
    protected void handleError(Event e, Exception ex) { log.error("Fail", ex); }
    
    @Override public int getOrder() { return order; }
    public void setOrder(int order) { this.order = order; }
}

// 3. 具體實現輕量
public class UserLoginListener extends AbstractEventListener {
    @Override protected void doHandle(Event e) { ... }
}

其他特殊用途

決策流程圖（文字版）

需要定義類型契約？
├─ 是 → 是否需要共享代碼/狀態/構造器？
│   ├─ 是 → 抽象類 (extends)
│   └─ 否 → 介面 (implements)
└─ 否 → 具體類

特殊情況：
- 類已繼承別的類 → 必須介面
- 需要多重組合能力 → 介面
- 需要非 public 成員/構造器 → 抽象類
- API 公開給第三方實現 → 介面 (SPI)
- 框架內部骨架 → 抽象類