萬盛學電腦網

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

PHP 物件導向開發完整筆記:從基礎到進階特性

Day 1:類別、物件與實例化基礎

什麼是 OOP?

物件導向程式設計(OOP)將資料(屬性)與行為(方法)封裝於類別中,透過實例化產生物件。核心四大特性:封裝、繼承、多型、抽象。

定義類別與成員

<?php
class MyPc {
    // 成員屬性(建議加可見性關鍵字)
    public $name;
    public $price;
    protected $serialNumber;
    private $internalId;
    
    // 成員方法
    public function playMovie() {
        return "播放電影";
    }
    
    public function playGame() {
        return $this->playMovie() . " 並運行遊戲"; // $this-> 呼叫同物件方法
    }
}
?>

實例化與存取

<?php
$pc1 = new MyPc();        // 建立實例
$pc1->name = "辦公電腦";   // 存取 public 屬性
echo $pc1->playMovie();   // 呼叫 public 方法

// 多個獨立實例
$pc2 = new MyPc();
$pc2->name = "遊戲電腦";
$pc3 = new MyPc();
?>

Day 2:$this、建構子、解構子

$this 關鍵字

代表當前物件實例,僅能在非靜態方法內使用,用於存取屬性($this->prop)與呼叫方法($this->method())。

建構子 __construct()

物件建立時自動呼叫,用於初始化狀態。

<?php
class MyPc {
    public $name;
    
    public function __construct($name = "") {
        $this->name = $name; // 初始化屬性
    }
    
    public function info() {
        return "{$this->name} 正在運行";
    }
}

$pc = new MyPc("筆電"); // 自動呼叫 __construct("筆電")
echo $pc->info(); // 筆電 正在運行
?>

解構子 __destruct()

物件銷毀時自動呼叫(記憶體釋出、請求結束、unset()),執行順序為後進先出。

<?php
class MyPc {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
        echo "建立:{$this->name}<br>";
    }
    
    public function __destruct() {
        echo "銷毀:{$this->name}<br>"; // 垃圾回收機制
    }
}

$pc1 = new MyPc("電腦A");
$pc2 = new MyPc("電腦B");
echo "程式結束前<br>";

// 輸出順序:
// 建立:電腦A
// 建立:電腦B
// 程式結束前
// 銷毀:電腦B (後建立先銷毀)
// 銷毀:電腦A
?>

Day 3:封裝與可見性控制

三種可見性關鍵字

關鍵字類別內部繼承類別外部程式碼
public✅✅✅
protected✅✅❌
private✅❌❌

封裝實戰:私有屬性 + 公開存取器

<?php
class MyPc {
    private $name; // 完全隱藏
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    // Getter
    public function getName() {
        return $this->name;
    }
    
    // Setter(可加驗證邏輯)
    public function setName($name) {
        if (strlen($name) > 0) {
            $this->name = $name;
        }
    }
    
    // 私有方法:內部實作細節
    private function powerOn() {
        return "{$this->name} --- 開機中...";
    }
    
    // 公開介面:暴露安全操作
    public function boot() {
        return $this->powerOn() . " --- OK";
    }
}

$pc = new MyPc("我的電腦");
// $pc->name = "駭客"; // ❌ 錯誤:私有屬性不可直接存取
$pc->setName("新電腦"); // ✅ 透過 setter
echo $pc->boot(); // 新電腦 --- 開機中... --- OK
?>

魔術存取器 __get / __set

攔截不可存取屬性的讀寫,實現動態屬性或驗證。

<?php
class MyPc {
    private $data = [];
    
    // 讀取不存在/不可見屬性時觸發
    public function __get($name) {
        return $this->data[$name] ?? null;
    }
    
    // 寫入不存在/不可見屬性時觸發
    public function __set($name, $value) {
        if ($name === 'price' && $value < 0) {
            throw new InvalidArgumentException("價格不可為負");
        }
        $this->data[$name] = $value;
    }
    
    public function __isset($name) {
        return isset($this->data[$name]);
    }
    
    public function __unset($name) {
        unset($this->data[$name]);
    }
}

$pc = new MyPc();
$pc->cpu = "i7";     // 觸發 __set
$pc->price = 30000;  // 觸發 __set(含驗證)
echo $pc->cpu;       // 觸發 __get → i7
isset($pc->cpu);     // 觸發 __isset
unset($pc->cpu);     // 觸發 __unset
?>

Day 4:繼承與多型

單一繼承 extends

PHP 採用單一繼承,一個子類別只能繼承一個父類別。

<?php
class Root {
    public function print1() {
        return "Root_print";
    }
}

class Son extends Root {
    public function print2() {
        return "Son_print";
    }
}

$p = new Son();
echo $p->print1(); // 繼承父類方法:Root_print
echo $p->print2(); // 子類方法:Son_print
?>

方法重寫與 parent:: 調用

<?php
class Root {
    public function greet() {
        return "Root 問候";
    }
}

class Son extends Root {
    public function greet() {
        // 重寫並延伸父類行為
        return parent::greet() . " → Son 延伸問候";
    }
}

$son = new Son();
echo $son->greet(); // Root 問候 → Son 延伸問候
?>

final 關鍵字:防止繼承/重寫

<?php
final class SecurityUtils {
    // 無法被繼承
}

class Base {
    final public function criticalMethod() {
        // 無法被子類別重寫
    }
}
?>

Day 5:抽象類別與介面

抽象類別 abstract class

  • 包含至少一個抽象方法(無主體)
  • 不能被實例化,只能被繼承
  • 子類別必須實作所有抽象方法才能實例化
<?php
abstract class Animal {
    protected $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    // 抽象方法:強制子類別實作
    abstract public function makeSound(): string;
    
    // 具體方法:提供共用邏輯
    public function introduce() {
        return "我是 {$this->name}," . $this->makeSound();
    }
}

class Dog extends Animal {
    public function makeSound(): string {
        return "汪汪!";
    }
}

class Cat extends Animal {
    public function makeSound(): string {
        return "喵~";
    }
}

// $a = new Animal(); // ❌ 錯誤:抽象類別不可實例化
$dog = new Dog("旺財");
echo $dog->introduce(); // 我是 旺財,汪汪!
?>

介面 interface

  • 定義契約:只宣告方法簽名,無實作(PHP 8.0 前)
  • 類別可實作多個介面(實現多型替代多重繼承)
  • PHP 8.0+ 介面可定義預設實作
<?php
interface Flyable {
    public function fly(): string;
}

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

class Duck implements Flyable, Swimmable {
    public function fly(): string {
        return "鴨子飛行";
    }
    
    public function swim(): string {
        return "鴨子游泳";
    }
}

function makeItFly(Flyable $entity) {
    echo $entity->fly();
}

$duck = new Duck();
makeItFly($duck); // 鴨子飛行
?>

Day 6:靜態成員、常量、後期靜態綁定

靜態屬性與方法

屬於類別而非實例,透過 ClassName::$prop、ClassName::method() 存取。

<?php
class Counter {
    private static $count = 0;
    
    public static function increment() {
        self::$count++;
    }
    
    public static function getCount(): int {
        return self::$count;
    }
}

Counter::increment();
Counter::increment();
echo Counter::getCount(); // 2(所有實例共享)
?>

類別常量 const

<?php
class Config {
    const VERSION = "1.0.0";
    const MAX_RETRY = 3;
    const STATUS = ['active' => 1, 'inactive' => 0];
}

echo Config::VERSION; // 1.0.0
// Config::VERSION = "2.0"; // ❌ 錯誤:常量不可修改
?>

後期靜態綁定 static::

解決繼承中 self:: 綁定到父類的問題。

<?php
class Model {
    public static function tableName() {
        return "base_table";
    }
    
    public static function find() {
        // self:: 會綁定到 Model
        // static:: 會綁定到實際呼叫的子類別
        return "查詢表:" . static::tableName();
    }
}

class User extends Model {
    public static function tableName() {
        return "users";
    }
}

echo Model::find(); // 查詢表:base_table
echo User::find();  // 查詢表:users (static:: 解析為 User)
?>

Day 7:魔術方法大全

方法觸發時機用途
__construct()new 實例化時初始化
__destruct()物件銷毀時清理資源
__call()呼叫不可見方法動態代理
__callStatic()呼叫不可見靜態方法靜態代理
__get()讀取不可見屬性動態屬性
__set()寫入不可見屬性屬性驗證/代理
__isset()isset() 檢查不可見屬性配合 __get
__unset()unset() 不可見屬性配合 __set
__toString()物件當字串用格式化輸出
__invoke()物件當函式呼叫可呼叫物件
__clone()clone 物件時深層複製邏輯
__sleep()serialize() 時指定序列化屬性
__wakeup()unserialize() 時重建資源連線
__serialize()PHP 7.4+ 序列化自訂序列化資料
__unserialize()PHP 7.4+ 反序列化自訂還原邏輯
__debugInfo()var_dump() 時控制除錯輸出

__invoke 範例:可呼叫物件

<?php
class Multiplier {
    private $factor;
    
    public function __construct($factor) {
        $this->factor = $factor;
    }
    
    public function __invoke($value) {
        return $value * $this->factor;
    }
}

$double = new Multiplier(2);
$triple = new Multiplier(3);

echo $double(5); // 10
echo $triple(5); // 15

// 可當作 callable 傳遞
$numbers = [1, 2, 3];
print_r(array_map($double, $numbers)); // [2, 4, 6]
?>

Day 8:Trait 程式碼複用

解決單一繼承限制,將方法組合「混入」類別。

<?php
trait Loggable {
    public function log($msg) {
        echo "[LOG] " . date('Y-m-d H:i:s') . " $msg\n";
    }
}

trait Timestampable {
    public $createdAt;
    public $updatedAt;
    
    public function touch() {
        $this->updatedAt = new DateTime();
    }
}

class Article {
    use Loggable, Timestampable; // 組合多個 Trait
    
    public $title;
    
    public function __construct($title) {
        $this->title = $title;
        $this->createdAt = new DateTime();
        $this->touch();
    }
    
    public function update($title) {
        $this->title = $title;
        $this->touch();
        $this->log("文章更新:$title");
    }
}

$art = new Article("PHP OOP 指南");
$art->update("PHP OOP 完整指南");
// 輸出:[LOG] 2024-01-15 10:30:00 文章更新:PHP OOP 完整指南
?>

Day 9:匿名類別

PHP 7+ 支援即時建立一次性類別。

<?php
interface Logger {
    public function log(string $msg);
}

// 即時實作介面
$logger = new class implements Logger {
    public function log(string $msg) {
        echo "[ANON] $msg\n";
    }
};

$logger->log("即時建立的記錄器");

// 延伸現有類別
$extended = new class(new DateTime()) extends DateTime {
    private $created;
    
    public function __construct(DateTime $dt) {
        parent::__construct($dt->format('Y-m-d'));
        $this->created = $dt;
    }
    
    public function getCreated() {
        return $this->created;
    }
};
?>

最佳實踐總結

  1. 單一職責:一個類別只做一件事
  2. 介面隔離:依賴抽象(介面)而非具體實作
  3. 組合優於繼承:用 Trait/組合替代深層繼承樹
  4. 封裝細節:屬性私有,提供受控存取器
  5. 型別宣告:PHP 7+ 善用標量/回傳型別提升可靠度
  6. 不可變物件:建構子注入、無 setter、withX() 回傳新實例
  7. 善用靜態分析:PHPStan/Psalm 檢查型別錯誤

結語

PHP 物件導向從基礎的類別/物件、$this、建構子,進階到封裝、繼承、抽象、介面、Trait、魔術方法、匿名類別,構成了現代 PHP 開發的核心基石。掌握這些特性並遵循 SOLID 原則,能建構出高內聚、低耦合、可測試、可維護的企業級應用程式。

copyright © 萬盛學電腦網 all rights reserved