php类入门

系统掌握PHP面向对象编程核心机制

www.xservx.com|备案号:蜀ICP备2026035467号-3

⚡ php类入门:面向对象编程基石

从过程到对象:理解PHP面向对象编程范式的根本转变

在PHP开发进阶过程中,php类入门标志着程序员从过程式思维向面向对象思维的关键跨越。过程式编程关注“做什么”,而面向对象编程则聚焦“谁来做”与“怎么做”。以用户登录功能为例,过程式方式需依次执行:接收数据→验证格式→查询数据库→比对密码→返回结果;而面向对象方式则构建User类,封装验证、认证、会话管理等行为,形成可复用的模块。

PHP自5.0版本起全面引入面向对象模型,后续版本持续增强类系统:PHP 7强化类型系统,PHP 7.4引入预加载,PHP 8支持构造器属性提升、联合类型、命名参数等特性。这些演进使PHP真正具备现代语言的OO能力。掌握php类入门不仅是技术需求,更是构建可维护、可扩展应用系统的必备能力。

面向对象三大支柱——封装、继承、多态,在PHP中均有完善支持:

  • 封装:通过访问控制(public/private/protected)隐藏实现细节,仅暴露必要接口
  • 继承:子类复用父类属性与方法,实现代码复用(单继承机制)
  • 多态:不同对象对同一方法调用产生不同行为,依赖继承与接口实现

相较于全局变量与函数组合,类提供更好的命名空间管理、状态封装与生命周期控制。例如,数据库连接类可封装连接参数、连接状态、查询方法,避免全局变量污染,提升代码健壮性。

⚙️ 定义类:对象的模板

从语法结构到最佳实践:构建规范的PHP类

类定义基础语法

类使用class关键字声明,后接类名(遵循大驼峰命名规范),包含属性与方法定义。类名应具有语义性,避免使用保留字(如class、function)作为名称。

class User { private $username; private $email; private $createdAt; public function __construct($username, $email) { $this->username = $username; $this->email = $email; $this->createdAt = date('Y-m-d H:i:s'); } public function getUsername() { return $this->username; } public function setEmail($email) { if (filter_var($email, FILTER_VALIDATE_EMAIL)) { $this->email = $email; } } }

类体中声明的变量称为属性(property),函数称为方法(method)。属性前必须指定访问修饰符(public/private/protected),PHP 8.1起支持readonly属性提升语法:

class Product { public readonly string $name; public readonly float $price; public function __construct( public string $name, public float $price ) {} }

readonly属性在构造后不可修改,提升数据安全性。PHP 8.0起支持属性类型声明,例如:

class Order { private int $id; private string $status = 'pending'; private array $items = []; public function addItem(string $item): void { $this->items[] = $item; } }

构造方法与析构方法

构造方法(__construct)在对象创建时自动调用,用于初始化属性。若未定义,PHP提供默认无参构造。构造方法可带参数,支持默认值与可变参数:

class Database { private $host = 'localhost'; private $port = 3306; private $connection; public function __construct( string $host = 'localhost', int $port = 3306, string $charset = 'utf8mb4' ) { $this->host = $host; $this->port = $port; // 连接数据库逻辑 } }

析构方法(__destruct)在对象销毁时调用,常用于释放资源(如关闭文件句柄、断开连接):

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

注意:析构方法在脚本结束时自动调用,但无法保证调用顺序,因此不依赖析构处理关键逻辑(如事务提交),应显式调用close()方法。

访问控制与封装实践

PHP提供三种访问控制修饰符:

  • public:类内外均可访问
  • private:仅类内部可访问
  • protected:类及子类可访问

合理使用封装原则,避免直接暴露属性。错误示例:属性公开导致外部随意修改状态:

class BankAccount { public $balance = 0; } // 外部可直接修改余额:$account->balance = -1000;

正确做法:私有属性 + 公开方法控制访问逻辑:

class BankAccount { private float $balance = 0.0; public function deposit(float $amount): void { if ($amount > 0) { $this->balance += $amount; } } public function withdraw(float $amount): bool { if ($amount > 0 && $this->balance >= $amount) { $this->balance -= $amount; return true; } return false; } public function getBalance(): float { return $this->balance; } }

PHP 8.1起支持属性readonly,进一步强化封装:

class Order { public readonly string $id; public readonly DateTimeImmutable $createdAt; public function __construct() { $this->id = uniqid(); $this->createdAt = new DateTimeImmutable(); } }

⚡ 魔术方法:魔法的开关

PHP魔术方法:动态行为的控制枢纽

__get()与__set():动态属性访问

当访问或设置不可见属性时触发。常用于实现懒加载或属性代理:

class User { private array $data = []; public function __set(string $name, mixed $value): void { $this->data[$name] = $value; } public function __get(string $name): mixed { return $this->data[$name] ?? null; } public function __isset(string $name): bool { return isset($this->data[$name]); } public function __unset(string $name): void { unset($this->data[$name]); } }

使用示例:

$user = new User(); $user->name = 'Alice'; // 调用__set() echo $user->name; // 调用__get()

__call()与__callStatic():动态方法调用

处理对不可见方法的调用,常用于构建DSL或代理模式:

class Logger { private array $channels = []; public function __call(string $name, array $arguments): void { $channel = $name; $message = $arguments[0] ?? ''; $this->channels[$channel][] = [ 'time' => date('Y-m-d H:i:s'), 'message' => $message ]; } public function getLogs(string $channel): array { return $this->channels[$channel] ?? []; } }

使用示例:

$logger = new Logger(); $logger->error('Database connection failed'); $logger->info('User logged in');

__callStatic()用于处理静态方法调用:

class Config { private static array $values = []; public static function __callStatic(string $name, array $arguments): mixed { return self::$values[$name] ?? null; } }

__toString()与__invoke():对象即值

__toString():对象被当作字符串使用时触发:

class Email { private string $address; public function __construct(string $address) { $this->address = $address; } public function __toString(): string { return $this->address; } }

使用示例:

$email = new Email('admin@example.com'); echo $email; // 输出:admin@example.com

__invoke():对象被当作函数调用时触发,实现可调用对象:

class TaxCalculator { private float $rate; public function __construct(float $rate) { $this->rate = $rate; } public function __invoke(float $amount): float { return $amount * (1 + $this->rate); } }

使用示例:

$calculator = new TaxCalculator(0.13); $total = $calculator(100.0); // 相当于调用__invoke()

🔗 继承与复用:代码复用的基石

单继承机制与trait复用的平衡艺术

继承基础语法

使用extends关键字实现单继承,子类继承父类所有非私有属性与方法:

class Vehicle { protected string $brand; public function __construct(string $brand) { $this->brand = $brand; } public function getBrand(): string { return $this->brand; } } class Car extends Vehicle { private int $doors; public function __construct(string $brand, int $doors) { parent::__construct($brand); $this->doors = $doors; } public function getDoors(): int { return $this->doors; } }

注意:子类可覆盖父类方法,但访问级别不能更严格(如public覆盖private非法)。

final关键字:禁止继承与覆盖

使用final修饰类禁止继承,修饰方法禁止覆盖:

final class DatabaseConnection { public function connect() { } } // class ExtendedConnection extends DatabaseConnection {} // 报错

PHP 8.0起支持final类中使用private方法覆盖(因private不可继承):

class ParentClass { private function helper() { return 'parent'; } } class ChildClass extends ParentClass { private function helper() { return 'child'; } // 允许 }

trait:横向复用的利器

解决单继承局限性,实现代码横向复用:

trait LoggerTrait { public function log(string $message): void { file_put_contents('app.log', date('Y-m-d') . ": $message\n", FILE_APPEND); } } class UserService { use LoggerTrait; public function createUser(string $name): void { $this->log("Creating user: $name"); // 创建用户逻辑 } }

冲突解决:当多个trait含同名方法时,需用insteadof指定使用哪个,或用as重命名:

trait A { public function foo() { return 'A'; } } trait B { public function foo() { return 'B'; } } class MyClass { use A, B { A::foo insteadof B; // 使用A的foo B::foo as bar; // 将B的foo重命名为bar } }

trait可声明属性,但需注意可见性一致性:

trait ConfigTrait { protected array $config = []; }

🔄 多态:行为的多样性

通过接口与抽象类实现运行时动态绑定

多态核心原理

多态指“同一操作作用于不同对象,产生不同效果”。PHP中通过继承接口或抽象类实现:

interface PaymentMethod { public function pay(float $amount): bool; } class CreditCardPayment implements PaymentMethod { public function pay(float $amount): bool { echo "Processing credit card payment: $amount\n"; return true; } } class PayPalPayment implements PaymentMethod { public function pay(float $amount): bool { echo "Processing PayPal payment: $amount\n"; return true; } } class Checkout { public function process(PaymentMethod $payment, float $amount): void { $payment->pay($amount); } }

使用示例:

$checkout = new Checkout(); $checkout->process(new CreditCardPayment(), 99.99); $checkout->process(new PayPalPayment(), 49.50);

运行时根据实际对象类型调用对应方法,实现多态。

类型提示与协变/逆变

PHP 7.2起支持返回类型协变(covariant),PHP 7.4起支持参数类型逆变(contravariant):

class Animal {} class Dog extends Animal {} interface Repository { public function get(): Animal; } class DogRepository implements Repository { public function get(): Dog { // 返回类型协变 return new Dog(); } }

逆变示例(参数类型可放宽):

class Service { public function handle(Dog $dog): void {} } class ExtendedService extends Service { public function handle(Animal $animal): void { // 参数类型逆变 // ... } }

🧱 抽象类:半成品的模板

强制子类实现特定方法的基类设计

抽象类语法

使用abstract修饰,可包含抽象方法(无实现)与具体方法:

abstract class Shape { abstract public function area(): float; public function describe(): string { return "Area: " . $this->area(); } } class Circle extends Shape { private float $radius; public function __construct(float $radius) { $this->radius = $radius; } public function area(): float { return pi() * $this->radius ** 2; } }

抽象类不能直接实例化,必须由子类实现所有抽象方法。

抽象类 vs 接口

对比核心差异:

特性抽象类接口
方法实现可含具体方法仅能含方法签名
属性可含属性不能含属性
构造方法可含不能含
多重继承不支持支持(实现多个接口)
访问修饰符任意仅public

选择原则:

  • 需共享代码实现 → 抽象类
  • 定义契约规范 → 接口

📋 接口:契约的定义

接口的多实现与默认方法

接口基础

接口使用interface声明,方法默认public,实现类必须实现所有方法:

interface Cache { public function get(string $key): mixed; public function set(string $key, mixed $value): bool; public function delete(string $key): bool; } class FileCache implements Cache { public function get(string $key): mixed { } public function set(string $key, mixed $value): bool { } public function delete(string $key): bool { } }

接口继承

接口可继承多个接口,形成接口层次:

interface Readable { public function read(): string; } interface Writable { public function write(string $data): int; } interface ReadWrite extends Readable, Writable {}

默认方法(PHP 8.0+)

接口可含默认实现方法:

interface Logger { public function log(string $message): void; public function debug(string $message): void { $this->log("[DEBUG] $message"); } } class SimpleLogger implements Logger { public function log(string $message): void { echo $message . "\n"; } }

使用示例:

$logger = new SimpleLogger(); $logger->debug("System started"); // 自动调用log()

🧩 trait复用:灵活的组合

trait的冲突解决与优先级规则

trait核心优势

trait解决PHP单继承局限,实现跨类方法复用,避免继承层次过深:

trait Timestampable { public function setCreatedAt(): void { $this->created_at = date('Y-m-d H:i:s'); } } class Post { use Timestampable; private string $created_at; public function __construct() { $this->setCreatedAt(); } } class Comment { use Timestampable; private string $created_at; }

冲突解决规则

当多个trait含同名成员时:

  1. 使用insteadof指定优先使用哪个trait的方法
  2. 使用as重命名冲突方法
  3. 子类覆盖trait方法
trait A { public function test() { return 'A'; } } trait B { public function test() { return 'B'; } } class Test { use A, B { A::test insteadof B; B::test as testB; } }

📁 命名空间:避免命名冲突

命名空间的组织与自动加载基础

命名空间基础

使用namespace关键字定义,避免类名冲突:

namespace App\Database; class Connection { // ... }

使用时需指定完整命名空间或使用use导入:

use App\Database\Connection; $db = new Connection();

命名空间规则

  • 必须在文件顶部声明(除declare外)
  • 全局代码需用namespace {}包裹或不声明
  • 支持子命名空间:App\Database\PDO

自动加载基础

命名空间与PSR-4自动加载配合:

spl_autoload_register(function ($class) { $prefix = 'App\\'; $base_dir = __DIR__ . '/src/'; $len = strlen($prefix); if (strncmp($prefix, $class, $len) !== 0) { return; } $relative_class = substr($class, $len); $file = $base_dir . str_replace('\\', '/', $relative_class) . '.php'; if (file_exists($file)) { require $file; } });

🚀 自动加载:按需加载类文件

从spl_autoload_register到Composer自动加载

自动加载原理

自动加载避免手动require所有类文件,实现按需加载:

spl_autoload_register('myAutoloader'); function myAutoloader($className) { $path = __DIR__ . '/classes/' . $className . '.php'; if (file_exists($path)) { require_once $path; } }

当使用未加载的类时自动调用注册函数。

PSR-4规范

现代PHP项目标准自动加载规范:

  • 命名空间与目录结构对应
  • 类名与文件名一致
  • 每个文件一个类

示例结构:

src/ ├── Database/ │ └── Connection.php └── Model/ └── User.php

类定义:

namespace App\Database; class Connection { }

Composer自动加载

使用composer.json配置自动加载:

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

运行composer dump-autoload生成自动加载文件。

✨ 魔术方法详解

PHP 8.1+新增与高级应用

__isset()与__unset():isset/unset拦截

当对不可见属性使用isset()或unset()时触发:

class User { private array $data = ['name' => 'Alice']; public function __isset(string $name): bool { return isset($this->data[$name]); } public function __unset(string $name): void { unset($this->data[$name]); } }

使用示例:

$user = new User(); isset($user->name); // 调用__isset() unset($user->name); // 调用__unset()

__clone()与__sleep():对象复制与序列化

__clone():对象克隆后调用,用于重置状态:

class Session { private $id; private $data = []; public function __clone() { $this->id = uniqid(); $this->data = []; } }

__sleep():序列化前调用,返回需序列化的属性名:

class Database { private $connection; public function __sleep(): array { return ['host', 'port']; // 不序列化连接资源 } }

__wakeup():反序列化后调用,重建资源:

class Database { public function __wakeup(): void { $this->connect(); // 重建连接 } }

__debugInfo()与__serialize():调试与序列化

__debugInfo():var_dump()输出时调用:

class User { private string $password; public function __debugInfo(): array { return [ 'username' => $this->username, 'password' => '********' ]; } }

__serialize()与__unserialize()(PHP 7.4+):

class Config { private array $data = []; public function __serialize(): array { return ['data' => $this->data]; } public function __unserialize(array $data): void { $this->data = $data['data']; } }

🎨 设计模式应用

php类入门实战:常用设计模式实现

单例模式

确保类仅有一个实例:

class Singleton { private static ?self $instance = null; private function __construct() {} public static function getInstance(): self { if (self::$instance === null) { self::$instance = new self(); } return self::$instance; } private function __clone() {} public function __wakeup() {} }

工厂模式

创建对象而不暴露创建逻辑:

class LoggerFactory { public static function create(string $type): Logger { return match($type) { 'file' => new FileLogger(), 'database' => new DatabaseLogger(), default => new StdoutLogger() }; } }

观察者模式

对象状态变化通知依赖对象:

interface Observer { public function update(string $event, mixed $data); } class Subject { private array $observers = []; public function attach(Observer $observer): void { $this->observers[] = $observer; } public function notify(string $event, mixed $data): void { foreach ($this->observers as $observer) { $observer->update($event, $data); } } }

🎯 最佳实践

php类入门进阶建议

设计原则

  • 单一职责:一个类只做一件事
  • 开闭原则:对扩展开放,对修改关闭
  • 依赖倒置:依赖抽象而非具体实现
  • 接口隔离:客户端不应依赖不需要的接口

编码规范

  • 使用PSR-12编码规范
  • 类名大驼峰,方法小驼峰
  • 私有属性前加下划线(可选)
  • 方法参数类型提示
  • 返回类型声明

测试驱动

使用PHPUnit编写单元测试:

class UserTest extends TestCase { public function testCanCreateUser(): void { $user = new User('Alice', 'alice@example.com'); $this->assertEquals('Alice', $user->getUsername()); } }