萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> PHP 程式設計

PHP 介面與抽象類別完整比較與實戰應用指南

介面與抽象類別是 PHP 物件導向設計的核心支柱,正確選擇與使用決定架構的彈性與維護性。本文深度比較兩者異同、語法規則、設計模式應用與決策指南。

抽象類別詳細規則

定義與特性

  • 使用 `abstract class` 宣告,不可直接實例化
  • 可包含**抽象方法**(無主體、需子類實作)與**具體方法**(有實作)
  • 可定義屬性(`public`/`protected`/`private`)、常數、建構子
  • 單一繼承:一個類別只能 `extends` 一個抽象類別

程式碼範例

<?php
abstract class Animal {
    protected string $name;
    protected int $age = 0;
    
    public function __construct(string $name) {
        $this->name = $name;
    }
    
    // 具體方法:共用邏輯
    public function getName(): string {
        return $this->name;
    }
    
    public function birthday(): void {
        $this->age++;
        echo "{$this->name} 過生日了!今年 {$this->age} 歲。\n";
    }
    
    // 抽象方法:強制子類實作
    abstract public function makeSound(): void;
    abstract protected function move(): void;
}

// 子類必須實作所有抽象方法才能實例化
class Dog extends Animal {
    public function makeSound(): void {
        echo "{$this->name}: 汪汪!\n";
    }
    
    protected function move(): void {
        echo "{$this->name} 四腳奔跑\n";
    }
    
    // 可覆寫具體方法
    public function birthday(): void {
        parent::birthday();
        echo "給 {$this->name} 一根骨頭!\n";
    }
}

$dog = new Dog('旺財');
$dog->makeSound(); // 旺財: 汪汪!
$dog->move();      // 旺財 四腳奔跑(protected 需在類內呼叫)
$dog->birthday();  // 旺財 過生日了!今年 1 歲。給 旺財 一根骨頭!

關鍵規則補充

  1. 存取層級不能收窄:父類 `protected` 抽象方法,子類實作只能是 `protected` 或 `public`,不能是 `private`
  2. 抽象類別可繼承抽象類別:中介層可部分實作,延遲到葉子類別完成
  3. 建構子可被繼承:子類未定義建構子時自動呼叫父類建構子

介面詳細規則

定義與特性

  • 使用 `interface` 宣告,完全抽象(PHP 8.0 前無方法主體)
  • 只能定義 `public` 方法(PHP 8.1+ 可定義 `protected`/`private` 抽象方法,但罕用)
  • 可定義常數(`const`),不可定義屬性
  • 多重實作:一個類別可 `implements` 多個介面
  • 介面可繼承多個介面(`interface C extends A, B`)

程式碼範例

<?php
interface Flyable {
    public const MAX_ALTITUDE = 10000;
    public function fly(): void;
    public function land(): void;
}

interface Swimmable {
    public function swim(): void;
}

// 類別實作多個介面
class Duck implements Flyable, Swimmable {
    public function fly(): void {
        echo "鴨子飛行,高度不超過 " . Flyable::MAX_ALTITUDE . " 公尺\n";
    }
    public function land(): void { echo "鴨子降落\n"; }
    public function swim(): void { echo "鴨子游泳\n"; }
}

// 介面繼承
interface Migratory extends Flyable {
    public function migrate(): void;
}

class WildGoose implements Migratory {
    public function fly(): void { echo "大雁排成 V 字飛行\n"; }
    public function land(): void { echo "大雁降落湖邊\n"; }
    public function migrate(): void { echo "大雁遷徙南方\n"; }
    // 必須實作 Flyable 的所有方法 + Migratory 自己的方法
}

PHP 8.0+ 新特性:介面預設實作

<?php
interface Loggable {
    public function log(string $message): void;
    
    // PHP 8.0+ 介面可提供預設實作
    public function logInfo(string $message): void {
        $this->log("[INFO] $message");
    }
    
    public function logError(string $message): void {
        $this->log("[ERROR] $message");
    }
}

class FileLogger implements Loggable {
    private $fp;
    public function __construct(string $path) { $this->fp = fopen($path, 'a'); }
    public function log(string $message): void {
        fwrite($this->fp, date('Y-m-d H:i:s') . " $message\n");
    }
    // logInfo、logError 直接繼承預設實作,無需重寫
}

抽象類別 vs 介面:核心差異比較

維度抽象類別介面
關鍵字`abstract class``interface`
關係語意**是一種** — 強調繼承體系、共同本質**能做什麼** — 強調行為契約、能力
繼承/實作單一繼承 (`extends`)多重實作 (`implements`)
方法主體可有具體方法 + 抽象方法PHP 8.0 前全抽象,8.0+ 可有預設實作
屬性/狀態可定義屬性、常數、建構子僅常數(PHP 8.1+ 可有私有抽象方法但無屬性)
存取修飾詞完整支援方法預設 `public`,常數 `public`
適用場景共享核心邏輯、狀態、模板方法模式定義契約、插件系統、跨層級解耦

設計決策指南:何時用哪個?

使用抽象類別的情境

  • 多個子類別共享**核心邏輯/狀態**(如資料庫連線、設定、日誌器)
  • 需要**模板方法模式**:定義演算法骨架,延遲特定步驟給子類
  • 建構子邏輯複雜,需強制子類呼叫 `parent::__construct()`
  • 類別之間有明顯的**層級關係**(如 `Animal` → `Mammal` → `Dog`)

使用介面的情境

  • 定義**行為契約**,不關心實作細節(如 `LoggerInterface`、`CacheInterface`)
  • 類別需要**多重能力組合**(如 `User` 同時 `Authenticatable`、`Notifiable`、`Exportable`)
  • 跨領域/跨層級解耦(Controller 依賴 `RepositoryInterface` 而非具體 `UserRepository`)
  • 第三方擴充點:讓外部開發者實作你的介面(PSR 標準皆為介面)

實戰組合模式:抽象類別實作介面

<?php
// 定義契約
interface RepositoryInterface {
    public function find(int $id): ?object;
    public function save(object $entity): void;
    public function delete(object $entity): void;
}

// 抽象基底類別提供共用資料庫邏輯
abstract class AbstractRepository implements RepositoryInterface {
    protected PDO $pdo;
    protected string $table;
    
    public function __construct(PDO $pdo, string $table) {
        $this->pdo = $pdo;
        $this->table = $table;
    }
    
    // 共用實作
    public function find(int $id): ?object {
        $stmt = $this->pdo->prepare("SELECT * FROM {$this->table} WHERE id = ?");
        $stmt->execute([$id]);
        return $this->hydrate($stmt->fetch(PDO::FETCH_ASSOC));
    }
    
    public function save(object $entity): void {
        $data = $this->extract($entity);
        if (isset($data['id'])) {
            $this->update($data);
        } else {
            $this->insert($data);
        }
    }
    
    // 抽象方法:留給具體 Repository 實作
    abstract protected function hydrate(array $row): object;
    abstract protected function extract(object $entity): array;
    abstract protected function insert(array $data): void;
    abstract protected function update(array $data): void;
}

// 具體實作
class UserRepository extends AbstractRepository {
    public function __construct(PDO $pdo) {
        parent::__construct($pdo, 'users');
    }
    
    protected function hydrate(array $row): object {
        $user = new User();
        $user->id = $row['id'];
        $user->name = $row['name'];
        $user->email = $row['email'];
        return $user;
    }
    
    protected function extract(object $entity): array {
        return ['id' => $entity->id, 'name' => $entity->name, 'email' => $entity->email];
    }
    
    protected function insert(array $data): void {
        $stmt = $this->pdo->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
        $stmt->execute([$data['name'], $data['email']]);
        $data['id'] = $this->pdo->lastInsertId();
    }
    
    protected function update(array $data): void {
        $stmt = $this->pdo->prepare("UPDATE users SET name=?, email=? WHERE id=?");
        $stmt->execute([$data['name'], $data['email'], $data['id']]);
    }
}

常見設計錯誤與重構建議

copyright © 萬盛學電腦網 all rights reserved
錯誤模式問題重構方向
大而全的抽象基底類別違反介面隔離原則,子類被迫繼承不需要的方法拆分為多個介面 + 組合模式
介面定義太多細節方法實作類別爆炸,違反依賴倒置精簡介面,只保留核心契約
用繼承代替組合單一繼承限制,耦合度高抽象類別僅共用核心邏輯,能力用介面組合
介面只有單一實作且永不變過度設計,增加複雜度YAGNI 原則:需要時再抽象