PHP 面向对象编程：解决继承中遇到的 NULL 值问题与正确设计类关系

本文深入探讨 PHP 面向对象编程中常见的 NULL 值问题，重点讲解了如何正确使用 __construct 方法作为类构造函数来初始化对象属性，以及如何区分和恰当应用类之间的继承（is-a）与聚合（has-a）关系。通过具体代码示例，指导开发者避免因构造函数误用或不当继承设计导致的运行时错误，优化代码结构和可维护性。

1. 问题剖析：为何出现 NULL 值？

在 PHP 面向对象编程中，当尝试创建对象并为其属性赋值时，如果操作不当，可能会导致属性值为 NULL。原始代码中，Clinic 类在尝试通过 assignPatient 方法添加 Patient 对象时，遇到了这个问题。

// 原始 Patient 类片段
class Patient{
    private $name;
    private $age;
    private $gender;

    public function record($name, $age, $gender){
        $this->name = $name;
        $this->age = $age;
        $this->gender = $gender;
    }
    // ...
}

// 原始 Clinic 类片段
class Clinic extends Patient{
    private $patients = [];

    public function assignPatient($name, $age, $gender){
        // 问题所在：这里调用了 new Patient()
        // 但 Patient 类中没有定义构造函数，record() 也未被调用
        $this->patients[] = new Patient($name, $age, $gender);
    }
    // ...
}

导致 NULL 值输出的主要原因有两点：

1. 构造函数缺失或误用： 在 Patient 类中定义了一个名为 record 的方法来设置属性，但它并不是 PHP 的特殊方法 __construct。当通过 new Patient(...) 创建对象时，PHP 默认会寻找并执行 __construct 方法来初始化对象。如果 __construct 不存在，且没有其他方式在对象创建时显式调用 record 方法，那么 Patient 对象的 $name, $age, $gender 属性将保持其默认的 NULL 值。
2. 不恰当的类继承关系： Clinic extends Patient 表达的是“诊所是一种病人”的“is-a”关系，这在逻辑上是不合理的。一个诊所通常是管理或包含病人的，而不是病人本身。这种不恰当的继承关系虽然不是导致 NULL 值的直接原因，但它混淆了类的职责，增加了代码的复杂性和理解难度。

2. PHP 构造函数 __construct 的正确使用

PHP 中的 __construct 是一个特殊的方法，被称为构造函数。当使用 new 关键字创建类的实例时，该方法会自动被调用。它的主要作用是初始化新创建的对象，例如设置属性的初始值、执行必要的设置逻辑等。

为了解决 Patient 对象属性为 NULL 的问题，我们需要将 record 方法重命名为 __construct，并确保它在对象创建时接收并设置所需的参数。

<?php class Patient{
    private $name;
    private $age;
    private $gender;

    /**
     * 构造函数：在创建 Patient 对象时自动调用，用于初始化病人信息。
     *
     * @param string $name 病人姓名
     * @param int $age 病人年龄
     * @param string $gender 病人性别
     */
    public function __construct($name, $age, $gender){
        $this->name = $name;
        $this->age = $age;
        $this->gender = $gender;
    }

    // 获取病人姓名
    public function getName(){
        return $this->name;
    }

    // 获取病人年龄
    public function getAge(){
        return $this->age;
    }

    // 获取病人性别
    public function getGender(){
        return $this->gender;
    }
}
?>

通过上述修改，现在当我们执行 new Patient("Patrick star", 18, "Male") 时，__construct 方法会自动执行，并将传入的姓名、年龄和性别赋值给 $name, $age, $gender 属性，确保对象被正确初始化。

3. 理解类关系：继承与聚合

在面向对象设计中，正确地建立类之间的关系至关重要。常见的两种关系是继承（Inheritance）和聚合（Aggregation/Composition）。

3.1 继承（Inheritance）："is-a" 关系

继承表示一个类是另一个类的特殊类型。例如，“狗是一种动物”，那么 Dog 类可以继承 Animal 类。继承通过 extends 关键字实现。

• 特点： 子类会继承父类的公共（public）和受保护（protected）的属性和方法。子类可以重写父类的方法，也可以添加自己的新属性和方法。
• 适用场景： 当子类确实是父类的一种更具体的实现时。

在原始代码中，Clinic extends Patient 意味着“诊所是一种病人”。这显然不符合现实逻辑。一个诊所不是一个病人，它是一个管理病人的实体。因此，这种继承关系是不恰当的。

3.2 聚合（Aggregation/Composition）："has-a" 关系

聚合表示一个类包含另一个类的实例作为其成员。例如，“诊所拥有病人”，那么 Clinic 类会包含一个或多个 Patient 对象的集合。聚合通过在一个类中声明另一个类的实例作为属性来实现。

• 特点： 一个类作为另一个类的组成部分。被包含的类是独立存在的，也可以被其他类使用。
• 适用场景： 当一个类需要使用另一个类的功能或数据，并且它们之间是“拥有”或“包含”的关系时。

对于 Clinic 和 Patient 的关系，更合理的模型是聚合：一个 Clinic 对象“拥有”一个或多个 Patient 对象的集合。因此，Clinic 类不应该继承 Patient，而应该在其内部维护一个 Patient 对象的数组。

基于此，我们重构 Clinic 类，移除不必要的继承，并使其通过聚合关系管理 Patient 对象：

<?php class Clinic {
    private $patients = []; // 诊所拥有一组病人

    /**
     * 获取诊所中的所有病人列表。
     *
     * @return array 包含 Patient 对象的数组
     */
    public function getPatients(){
        return $this->patients;
    }

    /**
     * 向诊所添加一位新病人。
     *
     * @param string $name 病人姓名
     * @param int $age 病人年龄
     * @param string $gender 病人性别
     */
    public function assignPatient($name, $age, $gender){
        // 使用正确初始化的 Patient 对象添加到病人列表
        $this->patients[] = new Patient($name, $age, $gender);
    }

    /**
     * 根据索引从诊所中删除一位病人。
     *
     * @param int $index 要删除病人的索引
     */
    public function deletePatient($index){
        if (isset($this->patients[$index])) {
            unset($this->patients[$index]);
            // 重置数组索引以避免空洞，可选操作
            $this->patients = array_values($this->patients);
        }
    }
}
?>

4. 完整示例代码与运行结果

结合上述对 Patient 类构造函数的修正和 Clinic 类聚合关系的调整，以下是完整的优化代码示例：

<?php // Patient 类定义
class Patient{
    private $name;
    private $age;
    private $gender;

    public function __construct($name, $age, $gender){
        $this->name = $name;
        $this->age = $age;
        $this->gender = $gender;
    }

    public function getName(){
        return $this->name;
    }

    public function getAge(){
        return $this->age;
    }

    public function getGender(){
        return $this->gender;
    }
}

// Clinic 类定义
class Clinic {
    private $patients = [];

    public function getPatients(){
        return $this->patients;
    }

    public function assignPatient($name, $age, $gender){
        $this->patients[] = new Patient($name, $age, $gender);
    }

    public function deletePatient($index){
        if (isset($this->patients[$index])) {
            unset($this->patients[$index]);
            // 可选：重新索引数组，使键连续
            $this->patients = array_values($this->patients);
        }
    }
}

// 实例化并操作
$clinic = new Clinic();

$clinic->assignPatient("Patrick star", 18, "Male");
$clinic->assignPatient("SpongeBob Squarepants", 17, "Male");
$clinic->assignPatient("Eugene Krab", 28, "Male");

echo "Initial patient list:\n";
print_r($clinic->getPatients());

$clinic->deletePatient(1); // 删除索引为1的病人 (SpongeBob Squarepants)

echo "\nPatient list after deletion:\n";
print_r($clinic->getPatients());

?>

预期输出：

Initial patient list:
Array
(
    [0] => Patient Object
        (
            [name:Patient:private] => Patrick star
            [age:Patient:private] => 18
            [gender:Patient:private] => Male
        )

    [1] => Patient Object
        (
            [name:Patient:private] => SpongeBob Squarepants
            [age:Patient:private] => 17
            [gender:Patient:private] => Male
        )

    [2] => Patient Object
        (
            [name:Patient:private] => Eugene Krab
            [age:Patient:private] => 28
            [gender:Patient:private] => Male
        )

)

Patient list after deletion:
Array
(
    [0] => Patient Object
        (
            [name:Patient:private] => Patrick star
            [age:Patient:private] => 18
            [gender:Patient:private] => Male
        )

    [1] => Patient Object
        (
            [name:Patient:private] => Eugene Krab
            [age:Patient:private] => 28
            [gender:Patient:private] => Male
        )

)

从输出中可以看出，Patient 对象现在被正确初始化，并且 Clinic 类能够有效地管理病人列表，不再出现 NULL 值。

5. 注意事项与最佳实践

• 始终使用 __construct 初始化对象： 养成在需要初始化属性的类中定义 __construct 方法的习惯，确保对象在创建时处于有效状态。
• 仔细评估类之间的关系： 在设计类时，务必思考它们之间的真实关系。是“is-a”（继承）还是“has-a”（聚合/组合）？错误的类关系会导致设计缺陷、代码难以维护和理解。
• 继承的滥用： 继承是一种强耦合关系，应谨慎使用。只有当子类确实是父类的一个特化版本时才考虑继承。过度使用继承可能导致“脆弱的基类问题”和复杂的类层次结构。
• 聚合的灵活性： 聚合（或更强的组合）提供了更大的灵活性，允许在运行时动态地添加或移除对象，而不会强制建立父子关系。
• 封装原则： 保持属性的私有性（private 或 protected），并通过公共的 getter/setter 方法来访问和修改它们，这是良好的封装实践。
• 代码可读性与维护性： 清晰、逻辑合理的类设计能够显著提高代码的可读性和未来的可维护性。

以上是PHP 面向对象编程：解决继承中遇到的 NULL 值问题与正确设计类关系的详细内容。更多信息请关注PHP中文网其他相关文章！