PHP面向对象编程简介

1. OOP的基本概念

OOP（面向对象编程）是一种编程方法。其核心思想是将现实世界的事物抽象为对象。每个对象都有一定的属性和方法。这些属性和方法描述了现实世界中对象的行为和状态。您还可以在 PHP 中使用面向对象的方法进行编程。

在

OOP中，对象指的是特定的事物，例如人、狗或汽车。不同的对象有自己的属性（属性）和行为（方法）。例如，一个人有姓名、性别、年龄等属性，也有吃饭、睡觉、玩游戏等行为。在编程中，我们可以将对象视为类的实例。类是一种自定义类型，用于描述共享相同属性和方法的对象。

这是一个简单的 PHP 类，描述一个人的姓名、性别和年龄：

class Person {
    public $name;
    public $age;
    public $gender;
}

在这个类中我们定义了三个属性：$name、$age 和 $gender。这些属性是公共的，这意味着可以从类外部访问它们。接下来，我们可以创建一个 Person 对象并设置其属性：

$person = new Person();
$person->name = 'Jack';
$person->age = 20;
$person->gender = 'male';

在此示例中，我们首先创建一个名为 $person 的 Person 对象。接下来，我们通过“->”运算符访问类属性，并将它们设置为“Jack”、“20”和“man”。

2。类方法

类不仅可以有属性，还可以有方法。方法是类中的函数，用于执行某些任务，例如执行计算、显示数据等。

这是 Person 类的改进版本，添加了 showInfo() 方法：

class Person {
    public $name;
    public $age;
    public $gender;

    public function showInfo() {
        echo "Name: ".$this->name."
";
        echo "Age: ".$this->age."
";
        echo "Gender: ".$this->gender."
";
    }
}

在这个改进版本中，我们添加了一个 showInfo() 方法，可以将 $person 对象的属性打印到 HTML 页面。

接下来，我们可以使用以下代码创建一个 Person 对象并调用其 showInfo() 方法：

$person = new Person();
$person->name = 'Jack';
$person->age = 20;
$person->gender = 'male';
$person->showInfo();

运行上面的代码，您将得到以下输出：

Name: Jack
Age: 20
Gender: male

3。遗传与多态性

继承是OOP的核心概念。继承是指一个类可以继承另一个类的属性和方法。继承的类称为父类（或基类），继承自它的类称为子类。

下面是一个说明继承实现的示例：

class Animal {
    public $name;
    public $age;
    public $gender;

    public function showInfo() {
        echo "Name: ".$this->name."
";
        echo "Age: ".$this->age."
";
        echo "Gender: ".$this->gender."
";
    }
}

class Dog extends Animal {
    public function bark() {
        echo "Woof! Woof!
";
    }
}

在上面的示例中，我们定义了一个名为 Animal 的类，它具有三个属性：$name、$age 和 $gender，以及一个 showInfo() 方法。接下来，我们定义一个名为 Dog 的类，它继承自 Animal 类，并添加了 bark() 方法。

接下来我们可以创建一个 Dog 对象并调用它的 bark() 和 showInfo() 方法：

$dog = new Dog();
$dog->name = 'Snoopy';
$dog->age = 3;
$dog->gender = 'male';
$dog->showInfo();
$dog->bark();

运行上面的代码，您将得到以下输出：

Name: Snoopy
Age: 3
Gender: male
Woof! Woof!

多态性是面向对象编程中的另一个重要概念。多态性是指相同的操作在不同的目标上表现出不同的行为。在PHP中，多态性通常是通过重载和重写来实现的。

下面的例子说明了多态性的应用：

class Shape {
    public function area() {
        return 0;
    }
}

class Rectangle extends Shape {
    private $width;
    private $height;

    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function area() {
        return $this->width * $this->height;
    }
}

class Circle extends Shape {
    private $radius;

    public function __construct($radius) {
        $this->radius = $radius;
    }

    public function area() {
        return 3.14 * $this->radius * $this->radius;
    }
}

$shapes = array(new Rectangle(10, 20), new Circle(10));
foreach($shapes as $shape) {
    echo get_class($shape).": ".$shape->area()."
";
}

在这个例子中，我们定义了一个名为Shape的基类，它有一个area()方法来计算形状的面积。接下来，我们定义两个子类：矩形和圆形。两个子类都重载了area()方法来计算它们自己的面积。

在代码的最后，我们创建了两个对象：一个矩形对象和一个圆形对象，并将它们存储在 $shapes 数组中。接下来，我们使用foreach()函数循环遍历$shapes数组，分别调用每个对象的area()方法，并将结果打印到HTML页面。由于 Rectangle 和 Circle 类都实现了 area() 方法，因此可以以相同的方式处理它们。这是多态性的一个例子。

4。引用并复制

在 PHP 中，变量本身可以存储对对象的引用，而不是对象本身。这意味着当我们将一个对象分配给变量时，我们实际上是在变量中存储对该对象的引用，而不是创建一个新对象。

以下示例显示了对象引用的使用：

class Car {
    public $brand;
    public $color;
}

$car1 = new Car();
$car1->brand = 'Toyota';
$car1->color = 'Red';

$car2 = $car1;
$car2->color = 'Blue';  

echo "Car1 brand: ".$car1->brand."
";
echo "Car1 color: ".$car1->color."
";
echo "Car2 brand: ".$car2->brand."
";
echo "Car2 color: ".$car2->color."
";

在此示例中，我们创建一个名为 Car 的类，它具有两个属性：$brand 和 $color。接下来，我们创建一个名为 $car1 的 Car 对象，并将 $car1 的 $brand 属性设置为“Toyota”，将 $color 属性设置为“Red”。

接下来，我们将 $car1 引用分配给新变量 $car2。由于 $auto1 和 $auto2 都指向同一个对象，因此对 $car2 的更改会影响 $auto1。

最后我们打印$car1和$car2的$brand和$color属性，可以看到它们的$color属性的值已经变成了‘Blue’。

引用和复制的效果在PHP中非常关键。确保您了解如何复制和引用对象。

5。建造者和毁灭者

在PHP中，构造函数和析构函数是两个非常重要的函数。构造函数用于创建对象时的初始化操作，而析构函数用于销毁对象时的清理操作。

这是一个说明 PHP 中构造函数和析构函数用法的示例：

class Counter {
    private static $count = 0;

    public function __construct() {
        self::$count++;
    }

    public function __destruct() {
        self::$count--;
    }

    public function getCount() {
        return self::$count;
    }
}

$counter1 = new Counter();
echo "Count: ".$counter1->getCount()."
";

$counter2 = new Counter();
echo "Count: ".$counter2->getCount()."
";

unset($counter1);
echo "Count: ".$counter2->getCount()."
";

在上面的示例中，我们创建了一个名为 Counter 的类。 Counter 类有一个静态属性 $Count 和一个 __construct() 构造函数和一个 __destruct() 析构函数。在 __construct() 构造函数中，我们将 Counter::$count 属性递增 1，在 __destruct() 析构函数中，我们将 Counter::$count 属性递减 1。

在代码的最后，我们创建了两个 Counter 对象：$counter1 和 $counter2。它们的计数属性会相应地打印。接下来，我们使用 unset() 函数销毁 $counter1 对象，最后重新打印 $counter2 的 count 属性。您看到的输出是 2, 3, 2。这是因为 __construct() 和 __destruct() 方法确保在 $counter1 对象被销毁时正确更新 Counter::$count 属性的值。

6。接口和抽象类

在PHP中，用户界面（Interface）是一个用于声明函数的抽象类，它不能实现这些函数。接口只定义了协议，实现接口的类必须实现接口中定义的所有方法。

以下是使用用户界面的示例：

interface Shape {
    public function area();
    public function perimeter();
}

class Triangle implements Shape {
    private $a;
    private $b;
    private $c;

    public function __construct($a, $b, $c) {
        $this->a = $a;
        $this->b = $b;
        $this->c = $c;
    }

    public function area() {
        $s = ($this->a + $this->b + $this->c) / 2;
        return sqrt($s * ($s - $this->a) * ($s - $this->b) * ($s - $this->c));
    }

    public function perimeter() {
        return $this->a + $this->b + $this->c;
    }
}

$triangle = new Triangle(3, 4, 5);
echo "Area: ".$triangle->area()."
";
echo "Perimeter: ".$triangle->perimeter()."
";

上面的例子定义了一个名为Shape的接口，它有两个方法：area()和perimeter()。接下来定义Triangle类，它实现Shape接口并实现area()和perimeter()方法。

最后，创建一个 $triangle 对象并打印其面积和周长。

在PHP中，抽象类也是用来声明函数的类，它不能实现这些函数。抽象类通常用于为继承层次结构提供基本实现。继承抽象类的子类必须实现该抽象类