PHP后端十年：从0到资深开发者的10堂必修课

第2篇：进阶篇——面向对象编程与命名空间

面向对象编程（OOP）是现代 PHP 开发的基石。它不仅让代码更易维护、复用，还为我们搭建大型应用提供了清晰的架构。本篇将带你深入 PHP 的面向对象特性，从类与对象的基础，到继承、多态、魔术方法、Trait，再到命名空间与异常处理，构建完整的 OOP 知识体系。

---

一、类与对象基础

类是对象的蓝图，对象是类的实例。PHP 的面向对象语法简洁且功能强大。

1. 定义类、属性与方法、访问控制

一个最基本的类定义如下：

class User
{
    // 属性（成员变量）
    public $name;
    protected $email;
    private $password;

    // 构造函数，对象初始化时自动调用
    public function __construct($name, $email, $password)
    {
        $this->name = $name;
        $this->email = $email;
        $this->setPassword($password);
    }

    // 方法（成员函数）
    public function greet()
    {
        return "Hello, I'm {$this->name}";
    }

    protected function setPassword($password)
    {
        $this->password = password_hash($password, PASSWORD_DEFAULT);
    }

    private function hashPassword($password)
    {
        // 私有方法，只能在类内部调用
    }
}

访问控制（可见性）：

• public：任何地方都可以访问。
• protected：本类及子类可以访问。
• private：仅本类可以访问，子类不可见。

对象实例化：

$user = new User('Alice', 'alice@example.com', 'secret');
echo $user->greet(); // Hello, I'm Alice

2. 构造函数、析构函数、对象实例化

• 构造函数 __construct()：对象创建时自动执行，用于初始化属性。
• 析构函数 __destruct()：对象销毁时自动执行（如脚本结束或 unset），用于清理资源（如关闭文件句柄、数据库连接）。

class FileHandler
{
    private $handle;
    public function __construct($filename) {
        $this->handle = fopen($filename, 'r');
    }
    public function __destruct() {
        if ($this->handle) {
            fclose($this->handle);
        }
    }
}

实例化：使用 new 关键字创建对象。PHP 支持匿名类（PHP 7+），适合一次性使用的场景。

$obj = new class {
    public function sayHello() {
        echo "Hello from anonymous class";
    }
};
$obj->sayHello();

---

二、继承与多态

继承允许子类复用父类的属性和方法，并在此基础上扩展或重写。

1. extends 继承、重写方法、final 关键字

class Animal
{
    protected $name;
    public function __construct($name) {
        $this->name = $name;
    }
    public function speak() {
        return "Some sound";
    }
}

class Dog extends Animal
{
    // 重写父类方法
    public function speak() {
        return "Woof! I'm {$this->name}";
    }
}

$dog = new Dog('Buddy');
echo $dog->speak(); // Woof! I'm Buddy

• 子类可以访问父类的 public 和 protected 成员。
• 使用 parent:: 调用父类方法：

  public function speak() {
      return parent::speak() . " but I'm a dog!";
  }
  

• final 关键字阻止类被继承或方法被重写：

  final class FinalClass {}      // 不能被继承
  class ParentClass {
      final public function method() {} // 不能被子类重写
  }
  

2. 抽象类与接口

抽象类：无法实例化，用于定义子类的通用结构。包含抽象方法（没有方法体）和具体方法。

abstract class Shape
{
    abstract public function area(); // 抽象方法
    public function description() {
        return "This is a shape";
    }
}

class Circle extends Shape
{
    private $radius;
    public function __construct($radius) {
        $this->radius = $radius;
    }
    public function area() {
        return pi() * $this->radius ** 2;
    }
}

接口：定义一组方法契约，类可以实现多个接口。

interface Logger
{
    public function log($message);
}

interface Notifiable
{
    public function notify($message);
}

class EmailLogger implements Logger, Notifiable
{
    public function log($message) {
        // 写入日志文件
    }
    public function notify($message) {
        // 发送邮件
    }
}

接口可以继承其他接口：interface A extends B {}。

抽象类与接口的选择：

• 当需要共享代码实现时，使用抽象类。
• 当需要定义能力契约（“能做某事”）时，使用接口。PHP 8+ 允许在接口中定义默认方法（public function method() { ... }），但通常仍建议接口专注于契约。

---

三、高级特性

PHP 的面向对象还提供了一些灵活的特性，让代码更简洁、更强大。

1. 魔术方法（__get、__set、__call、__invoke）

魔术方法以双下划线开头，在特定场景下自动触发。

• __get($name) 和 __set($name, $value)：访问不可访问属性时触发。

class DataBag
{
    private $data = [];
    public function __set($name, $value) {
        $this->data[$name] = $value;
    }
    public function __get($name) {
        return $this->data[$name] ?? null;
    }
}
$bag = new DataBag();
$bag->username = 'alice'; // 调用 __set
echo $bag->username;       // 调用 __get

• __call($name, $arguments) 和 __callStatic($name, $arguments)：调用不可访问方法时触发。

class Proxy
{
    public function __call($name, $args) {
        echo "Calling $name with " . json_encode($args);
    }
}
$proxy = new Proxy();
$proxy->anyMethod('arg1', 'arg2'); // Calling anyMethod with ["arg1","arg2"]

• __invoke()：对象可以被当作函数调用。

class Greeter
{
    public function __invoke($name) {
        return "Hello, $name";
    }
}
$greet = new Greeter();
echo $greet('Alice'); // Hello, Alice

其他魔术方法：

• __toString()：定义对象转字符串时的输出。
• __clone()：对象克隆时调用。
• __sleep() / __wakeup()：序列化时控制。
• __debugInfo()：var_dump 时自定义输出。

2. Trait（代码复用）

Trait 是一种水平组合的代码复用机制，解决 PHP 单继承的限制。

trait Loggable
{
    public function log($message) {
        echo "[LOG] $message";
    }
}

trait Timestampable
{
    private $createdAt;
    public function setCreatedAt($date) {
        $this->createdAt = $date;
    }
}

class User
{
    use Loggable, Timestampable; // 引入多个 trait
}

$user = new User();
$user->log('User created');      // [LOG] User created
$user->setCreatedAt('2025-03-25');

解决 trait 方法冲突：使用 insteadof 和 as。

trait A { public function smallTalk() { echo 'a'; } }
trait B { public function smallTalk() { echo 'b'; } }

class Talker
{
    use A, B {
        B::smallTalk insteadof A;
        A::smallTalk as talk;
    }
}

Trait 中可以定义抽象方法，要求使用它的类必须实现。

---

四、命名空间与自动加载

命名空间解决了类名冲突问题，自动加载则免去了手动 require 的繁琐。

1. namespace、use、别名

• 定义命名空间：使用 namespace 关键字，必须放在文件开头（除 declare 外）。

// 文件: src/Model/User.php
namespace App\Model;

class User { /* ... */ }

• 导入命名空间：使用 use 关键字。

use App\Model\User;
$user = new User();

// 别名
use App\Model\User as AppUser;
$user = new AppUser();

• 全局空间：\ 前缀表示从全局根开始。

$date = new \DateTime();

2. PSR-4 自动加载规范

PSR-4 是 PHP-FIG 推荐的自动加载规范，将命名空间与文件路径一一对应。例如：

• 命名空间 App\Model 对应目录 src/Model
• 类 App\Model\User 对应文件 src/Model/User.php

composer.json 配置：

{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

执行 composer dump-autoload 后，生成 vendor/autoload.php。

3. Composer 自动加载原理

Composer 生成的自动加载文件主要做了两件事：

1. 注册一个 spl_autoload_register 回调，根据类名动态查找对应的文件。
2. 维护一个类名与文件路径的映射表（来自 classmap 配置），提升加载效率。

理解自动加载原理，有助于调试类找不到的问题。

---

五、异常处理

异常是 PHP 中处理运行时错误的标准方式。相比传统的错误报告，异常提供了更优雅的控制流。

1. try-catch-finally

try {
    $db = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
    // 可能抛出异常的代码
} catch (PDOException $e) {
    echo "数据库连接失败: " . $e->getMessage();
} catch (Exception $e) {
    echo "其他异常: " . $e->getMessage();
} finally {
    // 无论是否发生异常，都会执行（PHP 5.5+）
    echo "清理资源";
}

• catch 可以捕获特定类型的异常，多个 catch 按顺序匹配。
• finally 常用于资源释放。

2. 自定义异常类

自定义异常类通常继承自 Exception 类，可以添加额外属性和方法。

class ValidationException extends Exception
{
    private $errors;
    public function __construct($message, $errors = [], $code = 0, Throwable $previous = null) {
        parent::__construct($message, $code, $previous);
        $this->errors = $errors;
    }
    public function getErrors() {
        return $this->errors;
    }
}

// 使用
try {
    $errors = ['email' => '邮箱格式不正确'];
    throw new ValidationException('验证失败', $errors);
} catch (ValidationException $e) {
    print_r($e->getErrors());
}

3. 错误与异常的区别、错误处理器

• 错误（errors）：PHP 传统报告机制，如 E_NOTICE、E_WARNING。默认情况下会输出到日志或屏幕，但不影响脚本继续执行（致命错误除外）。
• 异常（exceptions）：使用 try/catch 捕获，可以优雅处理。

PHP 7+ 中，大部分错误可以被 Error 类捕获（如 TypeError、ParseError）。可以将 Error 作为异常处理。

try {
    // 可能产生 TypeError 的代码
} catch (Error $e) {
    echo "捕获到错误: " . $e->getMessage();
}

自定义错误处理器：使用 set_error_handler() 将错误转为异常，统一处理。

set_error_handler(function($severity, $message, $file, $line) {
    throw new ErrorException($message, 0, $severity, $file, $line);
});

这样所有 PHP 错误都会被抛出一个 ErrorException，可以被 try/catch 捕获。

---

总结

本篇深入学习了 PHP 面向对象编程的核心内容：

• 类与对象：掌握了定义类、属性、方法、访问控制，以及构造函数、析构函数的使用。
• 继承与多态：理解了 extends、方法重写、final，以及抽象类与接口在架构设计中的作用。
• 高级特性：魔术方法让代码更灵活，Trait 解决了单继承的局限。
• 命名空间与自动加载：通过 PSR-4 和 Composer 管理代码结构，告别手动 require。
• 异常处理：用 try/catch/finally 处理运行时错误，并自定义异常类。

面向对象是 PHP 进阶的必经之路。掌握这些知识后，你可以写出结构清晰、易于维护的后端代码。下一篇我们将进入 数据库篇，学习 MySQL 交互与 PDO 最佳实践，敬请期待！

---

思考题：

1. 抽象类和接口在什么场景下使用？它们能否互相替代？
2. Trait 中定义属性与普通类定义属性有什么需要注意的地方？
3. PSR-4 自动加载的具体规则是什么？如果你的类库命名空间是 Company\Package，文件应放在哪个目录？
4. 为什么推荐在全局设置一个错误处理器，将错误转为异常？

欢迎在评论区分享你的见解和疑问，一起讨论进步！