前言

本文深入探讨PHP面向对象编程的核心原理与实践，帮助开发者掌握模块化代码设计技巧，提升应用的可维护性和扩展性。
面向对象编程（OOP）是现代PHP开发的核心，它让代码更加模块化、可维护和可扩展。本文将深入讲解PHP面向对象编程的各个方面，以及如何与数据库进行交互。

1、面向对象基础概念

面向对象编程有三大核心特性：

• 封装：将数据和操作数据的方法组合在一起
• 继承：子类可以继承父类的属性和方法
• 多态：同一接口可以有不同的实现方式

2、类的定义和使用

基本类结构

<?php
class Animal {
    // 属性（成员变量）
    public $name = "小动物";
    protected $age = 3;
    private $birth = '2023';
    
    // 构造函数 - 创建对象时自动调用
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }
    
    // 析构函数 - 对象销毁时自动调用
    public function __destruct() {
        echo "对象 {$this->name} 被销毁了";
    }
    
    // 方法（成员函数）
    public function eat() {
        echo $this->name . "在吃饭";
    }
    
    public function say() {
        echo $this->name . "在说话";
    }
}

// 创建对象实例
$cat = new Animal("小猫", 2);
echo $cat->name;  // 访问公有属性
$cat->eat();      // 调用方法
?>

访问控制修饰符

<?php
class MyClass {
    public $publicVar = "公有属性";      // 任何地方都可以访问
    protected $protectedVar = "保护属性";  // 自身和子类可以访问
    private $privateVar = "私有属性";     // 只有自身可以访问
    
    public function getPrivateVar() {
        return $this->privateVar;  // 类内部可以访问私有属性
    }
    
    protected function protectedMethod() {
        echo "这是受保护的方法";
    }
    
    private function privateMethod() {
        echo "这是私有方法";
    }
}

$obj = new MyClass();
echo $obj->publicVar;        // ✓ 正确
echo $obj->getPrivateVar();  // ✓ 通过公有方法访问私有属性
// echo $obj->privateVar;    // ✗ 错误：无法访问私有属性
?>

静态属性和方法

<?php
class Counter {
    // 静态属性 - 属于类本身，所有实例共享
    public static $count = 0;
    
    // 类常量 - 不能被修改
    const VERSION = "1.0.0";
    
    public function __construct() {
        self::$count++;  // 使用 self:: 访问静态属性
    }
    
    // 静态方法 - 不需要实例化就可以调用
    public static function getCount() {
        return self::$count;
    }
    
    public static function getVersion() {
        return self::VERSION;  // 访问类常量
    }
}

// 直接调用静态方法，无需实例化
echo Counter::getCount();    // 0
echo Counter::VERSION;       // 1.0.0

// 创建实例会增加计数
$c1 = new Counter();
$c2 = new Counter();
echo Counter::getCount();    // 2
?>

3、继承和方法重写

<?php
// 父类
class Animal {
    protected $name;
    protected $age;
    
    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }
    
    public function speak() {
        echo "{$this->name} 发出声音";
    }
    
    // final 方法不能被重写
    final public function getId() {
        return uniqid();
    }
}

// 子类继承父类
class Cat extends Animal {
    private $breed;
    
    public function __construct($name, $age, $breed) {
        parent::__construct($name, $age);  // 调用父类构造函数
        $this->breed = $breed;
    }
    
    // 重写父类方法
    public function speak() {
        echo "{$this->name} 喵喵叫";
    }
    
    // 访问受保护的属性
    public function getAge() {
        return $this->age;
    }
}

// final 类不能被继承
final class Dog extends Animal {
    public function speak() {
        echo "{$this->name} 汪汪叫";
    }
}

$cat = new Cat("波斯猫", 3, "波斯");
$cat->speak();  // 波斯猫 喵喵叫
echo $cat->getAge();  // 3
?>

3、抽象类和接口

抽象类

<?php
// 抽象类不能被实例化，只能被继承
abstract class Shape {
    protected $color;
    
    public function __construct($color) {
        $this->color = $color;
    }
    
    // 普通方法
    public function getColor() {
        return $this->color;
    }
    
    // 抽象方法必须在子类中实现
    abstract public function calculateArea();
    abstract protected function getPerimeter();
}

class Circle extends Shape {
    private $radius;
    
    public function __construct($color, $radius) {
        parent::__construct($color);
        $this->radius = $radius;
    }
    
    // 实现抽象方法
    public function calculateArea() {
        return pi() * $this->radius * $this->radius;
    }
    
    protected function getPerimeter() {
        return 2 * pi() * $this->radius;
    }
}

$circle = new Circle("红色", 5);
echo $circle->calculateArea();  // 78.54
?>

接口

<?php
// 接口定义规范，只包含方法声明
interface Drawable {
    public function draw();
    public function resize($scale);
}

interface Movable {
    public function move($x, $y);
}

// 类可以实现多个接口
class Rectangle implements Drawable, Movable {
    private $width, $height, $x, $y;
    
    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
        $this->x = 0;
        $this->y = 0;
    }
    
    public function draw() {
        echo "绘制矩形：宽{$this->width}，高{$this->height}";
    }
    
    public function resize($scale) {
        $this->width *= $scale;
        $this->height *= $scale;
    }
    
    public function move($x, $y) {
        $this->x = $x;
        $this->y = $y;
    }
}

$rect = new Rectangle(10, 5);
$rect->draw();
$rect->resize(2);
$rect->move(100, 200);
?>

4、Trait 代码复用

<?php
// Trait 用于代码复用，解决单继承限制
trait Logger {
    public function log($message) {
        echo "[" . date('Y-m-d H:i:s') . "] " . $message . "\n";
    }
}

trait Cache {
    private $cache = [];
    
    public function setCache($key, $value) {
        $this->cache[$key] = $value;
    }
    
    public function getCache($key) {
        return $this->cache[$key] ?? null;
    }
}

class User {
    use Logger, Cache;  // 使用多个 Trait
    
    private $name;
    
    public function __construct($name) {
        $this->name = $name;
        $this->log("用户 {$name} 创建成功");
    }
}

// 处理 Trait 方法冲突
trait A {
    public function test() {
        echo "来自 Trait A";
    }
}

trait B {
    public function test() {
        echo "来自 Trait B";
    }
}

class MyClass {
    use A, B {
        B::test insteadof A;  // 使用 B 的 test 方法
        A::test as testA;     // 给 A 的 test 方法取别名
    }
}
?>

6、总结

本文全面介绍了PHP面向对象编程操作的核心知识面向对象编程要点：

1. 类和对象：理解属性、方法、构造函数和析构函数
2. 封装性：合理使用访问控制修饰符
3. 继承性：extends关键字和方法重写
4. 多态性：接口和抽象类的使用
5. 代码复用：Trait的灵活应用

实践建议

1. 强化封装：使用访问控制修饰符（如public、protected、private）保护数据，避免直接暴露属性，通过方法操作数据。
2. 合理利用继承：子类继承父类属性和方法时，重写关键函数（如speak()）以扩展功能，保持代码重用性。
3. 实现接口规范：通过接口（如Drawable、Movable）定义统一方法，确保类实现多态，提升扩展性。
4. 应用Trait复用代码：在单继承限制下，使用Trait（如Logger）嵌入通用功能（如日志记录），减少重复代码。
5. 管理对象生命周期：在构造函数初始化属性，析构函数清理资源，优化内存使用。