复习一下PHP中的类和对象

面向对象编程（OOP）是一种编程范式，它通过类和对象的概念来组织代码。PHP 作为一种广泛使用的服务器端脚本语言，从 PHP 5 开始就全面支持面向对象编程。本文将深入探讨 PHP 中类和对象的相关知识，包括类的定义、对象的创建、类的内置函数、魔术方法、继承、访问控制、静态成员、抽象类和接口，以及反射 API。

类的定义

在 PHP 中，使用 class 关键字来定义一个类。类是对象的蓝图，定义了对象的属性和方法。

<?php
// 定义一个名为Person的类
class Person {
    // 定义类的属性
    public $name;
    protected $age;
    private $id;

    // 定义类的构造函数
    public function __construct($name, $age, $id) {
        $this->name = $name;
        $this->age = $age;
        $this->id = $id;
    }

    // 定义类的方法
    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }
}
?>

创建对象

使用 new 关键字来创建类的实例（对象）：

<?php
// 创建Person类的实例
$person = new Person("Alice", 30, "P001");

// 调用对象的方法
echo $person->sayHello(); // 输出：Hello, my name is Alice
?>

类的内置函数

PHP 提供了一些与类和对象相关的内置函数，例如：

class_exists()：检查一个类是否已经定义。
get_class()：返回对象的类名。
property_exists()：检查对象或类中是否存在指定的属性。
method_exists()：检查对象或类中是否存在指定的方法。

示例：

<?php
// 使用class_exists()检查Person类是否存在
if (class_exists("Person")) {
    echo "Person类已定义。";
}

// 使用get_class()获取对象的类名
$person = new Person("Alice", 30, "P001");
echo get_class($person); // 输出：Person

// 使用property_exists()检查属性是否存在
if (property_exists($person, "name")) {
    echo "name属性存在。";
}

// 使用method_exists()检查方法是否存在
if (method_exists($person, "sayHello")) {
    echo "sayHello方法存在。";
}
?>

类的魔术方法

PHP 支持一些特殊的魔术方法，这些方法在特定的时机自动调用，例如：

__construct()：构造函数，在创建对象时自动调用。
__destruct()：析构函数，在销毁对象时自动调用。
__call()：当调用一个不可访问的方法时自动调用。
__get() 和 __set()：当访问或设置不可访问的属性时自动调用。

示例：

<?php
class Person {
    private $data = [];

    // 构造函数
    public function __construct($name, $age) {
        $this->data['name'] = $name;
        $this->data['age'] = $age;
    }

    // 析构函数
    public function __destruct() {
        echo "Person对象被销毁。";
    }

    // 调用不可访问的方法时调用
    public function __call($method, $args) {
        echo "调用了不可访问的方法：$method。";
    }

    // 访问不可访问的属性时调用
    public function __get($property) {
        if (array_key_exists($property, $this->data)) {
            return $this->data[$property];
        } else {
            return null;
        }
    }

    // 设置不可访问的属性时调用
    public function __set($property, $value) {
        $this->data[$property] = $value;
    }
}

// 创建Person类的实例
$person = new Person("Alice", 30);

// 访问不可访问的属性
echo $person->name; // 输出：Alice

// 设置不可访问的属性
$person->age = 31;

// 调用不可访问的方法
$person->undefinedMethod(); // 输出：调用了不可访问的方法：undefinedMethod。
?>

类的继承

在 PHP 中，可以使用 extends 关键字来实现类的继承：

<?php
// 定义一个名为Person的基类
class Person {
    public $name;
    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }
}

// 定义一个名为Student的类，继承自Person类
class Student extends Person {
    public $school;
    public function study() {
        return "I am studying at " . $this->school;
    }
}

// 创建Student类的实例
$student = new Student();
$student->name = "Bob";
$student->school = "XYZ University";

// 调用继承的方法
echo $student->sayHello(); // 输出：Hello, my name is Bob

// 调用Student类的方法
echo $student->study(); // 输出：I am studying at XYZ University
?>

类的访问控制

在 PHP 中，类的成员（属性和方法）可以有三种访问控制级别：

public：公有成员，可以在任何地方被访问。
protected：受保护成员，可以在类本身及其子类中被访问。
private：私有成员，只能在类本身中被访问。

示例：

<?php
// 定义一个名为Person的类
class Person {
    // 公有属性
    public $name;

    // 受保护属性
    protected $age;

    // 私有属性
    private $id;

    // 公有方法
    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }

    // 受保护方法
    protected function setAge($age) {
        $this->age = $age;
    }

    // 私有方法
    private function getId() {
        return $this->id;
    }
}

// 创建Person类的实例
$person = new Person();

// 访问公有属性
$person->name = "Alice";

// 无法直接访问受保护和私有属性
// $person->age = 30; // 这将导致错误
// $person->id = "P001"; // 这将导致错误

// 调用公有方法
echo $person->sayHello(); // 输出：Hello, my name is Alice

// 无法直接调用受保护和私有方法
// $person->setAge(30); // 这将导致错误
// $person->getId(); // 这将导致错误
?>

类的静态成员

在 PHP 中，可以使用 static 关键字来定义类的静态成员：

<?php
// 定义一个名为Person的类
class Person {
    // 静态属性
    public static $count = 0;

    // 构造函数
    public function __construct() {
        self::$count++;
    }

    // 静态方法
    public static function getCount() {
        return self::$count;
    }
}

// 创建Person类的实例
$person1 = new Person();
$person2 = new Person();

// 访问静态属性
echo Person::$count; // 输出：2

// 调用静态方法
echo Person::getCount(); // 输出：2
?>

类的抽象类和接口

在 PHP 中，还可以定义抽象类和接口：

抽象类：使用 abstract 关键字定义，不能被实例化，只能被继承。
接口：使用 interface 关键字定义，是一种特殊的抽象类，只包含方法签名，不包含方法实现。

示例：

<?php
// 定义一个抽象类
abstract class AbstractPerson {
    public $name;
    abstract public function sayHello();
}

// 定义一个接口
interface PersonInterface {
    public function study();
}

// 定义一个类，继承自抽象类，实现接口
class Student extends AbstractPerson implements PersonInterface {
    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }

    public function study() {
        return "I am studying.";
    }
}

// 创建Student类的实例
$student = new Student();
$student->name = "Bob";

// 调用方法
echo $student->sayHello(); // 输出：Hello, my name is Bob
echo $student->study(); // 输出：I am studying.
?>

类的反射

PHP 提供了强大的反射 API，允许我们在运行时获取类的详细信息，包括类名、属性、方法、常量等。反射 API 主要通过 ReflectionClass、ReflectionMethod、ReflectionProperty 等类来实现。

使用反射 API

<?php
// 定义一个名为Person的类
class Person {
    public $name;
    protected $age;
    private $id;

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

    public function sayHello() {
        return "Hello, my name is " . $this->name;
    }

    protected function setAge($age) {
        $this->age = $age;
    }

    private function getId() {
        return $this->id;
    }
}

// 使用反射API获取类的信息
$reflectionClass = new ReflectionClass('Person');

// 获取类名
echo $reflectionClass->getName(); // 输出：Person

// 获取类的所有方法
$methods = $reflectionClass->getMethods();
foreach ($methods as $method) {
    echo $method->getName() . "\n";
}

// 获取类的所有属性
$properties = $reflectionClass->getProperties();
foreach ($properties as $property) {
    echo $property->getName() . "\n";
}
?>

好啦！复习了 PHP 中类和对象的相关知识，包括类的定义、创建对象、类的内置函数、魔术方法、继承、访问控制、静态成员、抽象类和接口，以及反射 API