PHP的OOP：PHP 继承

最新推荐文章于 2024-06-24 16:09:26 发布

新华

最新推荐文章于 2024-06-24 16:09:26 发布

阅读量1.6k

点赞数 53

分类专栏： PHP教程文章标签： php 开发语言

本文链接：https://blog.csdn.net/mzgxinhua/article/details/137286693

版权

PHP教程专栏收录该内容

71 篇文章

订阅专栏

概述

PHP 中的继承是面向对象编程（OOP） 概念的一个基本概念，它允许一个类从另一个类继承属性和方法。继承支持代码重用，并促进类之间的分层结构。在PHP中，继承是使用“extends”关键字实现的，其中子类继承自单个超类。子类可以访问和修改继承的成员，以及定义其唯一成员。继承有助于创建更专用的类，这些类从基类继承通用功能，从而使代码组织和维护更加高效。

介绍

继承是面向对象编程（OOP）中的一个基本概念，它允许 PHP 中的类从其他类继承属性和方法。它促进了代码的可重用性，并促进了模块化和有组织的代码结构的创建。

在 PHP 中，继承是使用关键字 extends 实现的，其中子类扩展了父类。子类从父类继承所有非私有属性和方法，允许它重用和构建父类提供的功能。类之间的这种关系形成一种“is-a”关系，其中子类是父类的专用版本。

子类还可以通过提供其实现来重写继承的方法。这实现了自定义和灵活性，因为子类可以修改或增强继承方法的行为以满足其特定要求。

继承支持分层分类的概念，从而可以创建类层次结构。可以建立多个继承级别，其中类可以同时具有父类和子类。这种分层结构通过对相关类进行分组来促进代码组织并促进代码维护。

PHP 中继承的好处包括代码重用，因为通用功能可以封装在基类中并由多个派生类继承。这节省了开发时间，减少了代码重复，并促进了模块化设计。继承还促进了代码扩展性，允许通过创建扩展现有类的新类来添加新功能，而无需修改原始代码。

但是，必须明智地使用继承，因为使用不当会导致复杂的类层次结构和类之间的紧密耦合。保持清晰和合乎逻辑的继承结构，并确保在类之间真正存在“is-a”关系的情况下应用继承至关重要。

什么是PHP中的继承？

PHP 中的继承是面向对象编程（OOP） 中的一个基本概念，它允许类从其他类继承属性和方法。它促进了代码重用，并促进了类之间的分层结构。

继承是使用 PHP 中的 extends 关键字实现的，其中子类扩展父类。子类继承父类中定义的所有非私有属性和方法，使其能够利用和构建父类提供的功能。这将建立一种“is-a”关系，其中子类是父类的专用版本。

通过从父类继承，子类可以访问父类中定义的公共和受保护的属性和方法。它可以像在子类本身中定义一样使用它们。这促进了代码的可重用性，因为通用功能可以封装在基类中并由多个派生类继承。

除了继承属性和方法之外，子类还可以通过提供其实现来灵活地重写或扩展继承的方法。这允许子类自定义从父类继承的行为，并使其适应其特定需求。

继承支持创建类层次结构，其中类可以同时具有父类和子类。可以建立多层次的继承，形成反映不同类之间关系的层次结构。

PHP 中的继承允许类从父类继承属性和方法，从而实现代码重用、促进模块化并建立分层结构。它是面向对象编程的核心概念，有助于开发灵活且可维护的 PHP 应用程序。

在 PHP 中继承类的语法

在PHP中，继承类的语法如下：

class ChildClass extends ParentClass {
   // Class definition
}

在上面的语法中：

ChildClass 是将从 ParentClass 继承的子类的名称。
ParentClass 是包含要继承的属性和方法的父类的名称。
通过使用 extends 关键字，子类从父类继承所有公共和受保护的属性和方法。然后，子类可以访问和利用这些继承的成员。

需要注意的是，子类只能继承自 PHP 中的单父类。但是，可以通过创建类链来实现多级继承，其中每个子类都成为后续子类的父类。在编辑器中运行上述代码以获得更好、更清晰的解释。

PHP 中的访问修饰符

在 PHP 中，访问修饰符在继承中起着重要作用，因为它们定义了类层次结构中属性和方法的可见性和可访问性。PHP 中有三个访问修饰符可用：

公共：
公共访问修饰符允许从任何位置访问属性和方法，包括类、子类和类的实例外部。公共成员由子类继承，可以重写或扩展。
受保护：
受保护的访问修饰符将属性和方法的可见性限制为类本身及其子类。可以在类及其子类内访问受保护的成员，但不能从类层次结构外部访问。受保护的成员由子类继承，可以重写或扩展。
Private：
专用访问修饰符将属性和方法的可见性限制为定义它们的类。子类或类的实例无法访问或继承私有成员。它们只能在类本身内访问。因此，不能在子类中覆盖或扩展私有成员。

访问修饰符的选择取决于所需的封装和数据隐藏级别。公共成员提供最广泛的可见性，受保护的成员在类层次结构中提供有限的可见性，而私有成员则最受限制。

例：

class ParentClass {
    public $publicProperty;
    protected $protectedProperty;
    private $privateProperty;

    public function publicMethod() {
        // Code
    }

    protected function protectedMethod() {
        // Code
    }

    private function privateMethod() {
        // Code
    }
}

class ChildClass extends ParentClass {
    // Code
}

$child = new ChildClass();
$child->publicProperty = "Public Property"; // Accessible
$child->protectedProperty = "Protected Property"; // Accessible within the class hierarchy
$child->privateProperty = "Private Property"; // Not accessible

$child->publicMethod(); // Accessible
$child->protectedMethod(); // Accessible within the class hierarchy
$child->privateMethod(); // Not accessible

在上面的示例中，子类 ChildClass 继承了父类 ParentClass 的属性和方法。访问修饰符（public、protected 和 private）定义子类中继承成员的可见性和可访问性。在编辑器中运行上述代码以获得更好、更清晰的解释。

PHP 中的继承类型

继承是面向对象编程（OOP）中的核心概念，它允许类从其他类继承属性和方法。在 PHP 中，开发人员可以使用几种类型的继承来创建类层次结构并实现代码可重用性。让我们来探讨一下 PHP 中不同类型的继承：

1. 单一继承：

单一继承是指类从单个父类继承的场景。在PHP中，单一继承是最常用的继承类型。它允许类继承一个父类（也称为超类或基类）的属性和方法。

语法：

class ChildClass extends ParentClass {
   // Class definition
}

例

class Animal {
   public function sound() {
      echo "The animal makes a sound.";
   }
}

class Dog extends Animal {
   // Additional class definition for Dog
}

在编辑器中运行上述代码以获得更好、更清晰的解释。

2. 多重继承（不支持）：

多重继承是指一个类从多个父类继承的场景。但是，PHP 不直接支持多重继承。与其他一些编程语言不同，PHP 限制一个类同时继承多个类。施加此限制是为了避免因多个父类中的方法和属性名称冲突而产生的歧义和复杂性。

但是，PHP 提供了一种称为“Traits”的替代机制，它提供了一种类似于多重继承的代码重用形式。Traits 允许开发人员在多个类中重用方法集，而无需实际继承。可以使用 use 关键字将特征添加到类中。

3. 多级继承：

多级继承涉及从父类继承的类，以及该父类本身从另一个父类继承。这形成了一个层次结构或类链。在 PHP 中，多级继承允许类从类层次结构的多个级别继承属性和方法。

语法：

class ChildClass extends ParentClass {
   // Class definition
}

例：

class Animal {
   public function sound() {
      echo "The animal makes a sound.";
   }
}

class Mammal extends Animal {
   // Additional class definition for Mammal
}

class Dog extends Mammal {
   // Additional class definition for Dog
}

在上面的示例中，Dog 类继承自 Mammal 类，而 Mammal 类又继承自 Animal 类。因此，Dog 类继承了 Mammal 和 Animal 类的属性和方法。在编辑器中运行上述代码以获得更好、更清晰的解释。

4. 分层继承：

php 中的分层继承仅在多个类从单个父类继承时发生。在这种类型的继承中，一个父类充当基类，多个子类从中派生。

语法：

class ChildClass1 extends ParentClass {
   // Class definition
}

class ChildClass2 extends ParentClass {
   // Class definition
}

例

class Shape {

   public function area() {
      // Code to calculate the area
   }
}

class Circle extends Shape {
   // Additional class definition for Circle
}

class Rectangle extends Shape {
   // Additional class definition for Rectangle
}

在上面的示例中，Circle 和 Rectangle 类都继承自 Shape 类。它们共享 Shape 类中定义的通用功能，例如 area（）方法，但可能具有其他特定行为。在编辑器中运行上述代码以获得更好、更清晰的解释。

这些是 PHP 中的主要继承类型。每种类型都提供了不同的方法来构建类和实现代码重用。请务必根据应用程序的要求和设计选择适当的继承类型。继承是 PHP 中的一项强大功能，它使开发人员能够创建灵活和模块化的代码结构。

继承示例：子类继承父类的公共成员和受保护成员

继承是面向对象编程（OOP）中的一个基本概念，它允许类从其他类继承属性和方法。当子类从父类继承时，它将获得对父类的公共成员和受保护成员的访问权限，父类包括属性和方法。在此示例中，我们将探讨 PHP 中的子类如何继承和利用其父类的公共和受保护成员。

让我们考虑一个场景，其中有一个名为 Animal 的父类，用于定义与动物相关的常见属性和方法。Animal 类有一个名为 $name 的公共属性和一个名为 $age 的受保护属性。它还有一个名为 eat（）的公共方法和一个名为 sleep（）的受保护方法。子类 Dog 将从 Animal 类继承这些成员。

class Animal {
    public $name;
    protected $age;

    public function eat() {
        echo "The animal is eating.";
    }

    protected function sleep() {
        echo "The animal is sleeping.";
    }
}

class Dog extends Animal {
    // Additional class definition for Dog
}

在上面的示例中，Dog 类使用 extends 关键字扩展 Animal 类。通过扩展 Animal 类，Dog 类继承了 Animal 类的属性和方法。在编辑器中运行上述代码以获得更好、更清晰的解释。

现在，让我们创建一个 Dog 类的实例，并探索它如何访问和利用继承的成员。

$dog = new Dog();
$dog->name = "Buddy"; // Accessing the public property
echo $dog->name; // Output: Buddy

$dog->eat(); // Accessing the public method. Output: The animal is eating.

$dog->age = 3; // Not accessible as the age property is protected.
$dog->sleep(); // Not accessible as the sleep() method is protected.

在上面的代码中，我们创建了一个 Dog 类的对象$dog。由于 name 属性是公共的，因此我们可以使用 object 实例直接访问和修改它。同样，eat（）方法是公共的，因此我们可以使用对象实例调用它。在编辑器中运行上述代码以获得更好、更清晰的解释。

但是，age 属性和 sleep（）方法受到保护，这意味着它们不能从类层次结构外部直接访问。我们不能直接访问或修改 $age 属性，也不能使用对象实例调用 sleep（）方法。

受保护的成员只能在类及其子类中访问。因此，如果我们向 Dog 类添加其他方法，我们可以访问受保护的成员。

class Dog extends Animal {
    public function showAge() {
        echo "The dog's age is ". $this->age . " years.";
    }

    public function sleepDog() {
        $this->sleep();
    }
}

$dog = new Dog();
$dog->showAge(); // Output: The dog's age is 3 years.
$dog->sleepDog(); // Output: The animal is sleeping.

在更新的 Dog 类中，我们定义了两个新方法：showAge（）和 sleepDog（）。showAge（） 方法在类上下文中使用 $this 关键字直接访问受保护的 $age 属性。同样，sleepDog（） 方法使用 $this 关键字调用受保护的 sleep（）方法。在编辑器中运行上述代码以获得更好、更清晰的解释。

通过利用这些附加方法，我们可以间接访问和利用子类中父类的受保护成员。

PHP 中的继承允许子类从其父类继承公共和受保护的成员。这种继承支持代码重用，并促进类之间的分层结构。子类可以直接访问和利用继承的公共成员，但受保护的成员只能在类层次结构（包括子类本身）内访问。

通过扩展父类，子类可以在现有功能的基础上进行构建，并添加特定于其要求的新功能。继承是一种强大的机制，可增强 PHP 应用程序中的代码组织、模块化和可重用性。

方法重写示例

方法重写是面向对象编程中的一个概念，其中子类提供其父类中已定义的方法的实现。这允许子类根据其特定要求修改或扩展继承方法的行为。在这个例子中，我们将探讨PHP中的方法覆盖，并有详细的解释。

让我们考虑一个场景，我们有一个名为 Animal 的父类，它定义了一个名为 makeSound（）的方法。makeSound（） 方法输出动物发出的通用声音。

class Animal {
    public function makeSound() {
        echo "The animal makes a sound.";
    }
}

现在，让我们创建一个名为 Dog 的子类，用于扩展 Animal 类。我们将在 Dog 类中重写 makeSound（）方法，为狗的声音提供特定的实现。

class Dog extends Animal {
    public function makeSound() {
        echo "The dog barks.";
    }
}

在上面的示例中，Dog 类使用 extends 关键字扩展 Animal 类。通过扩展 Animal 类，Dog 类继承了 makeSound（）方法。但是，我们通过使用相同的名称重新定义它并修改其实现来覆盖 Dog 类中的方法。在编辑器中运行上述代码以获得更好、更清晰的解释。

现在，让我们创建一个 Dog 类的对象并调用 makeSound（）方法来查看被覆盖的行为。

$dog = new Dog();
$dog->makeSound(); // Output: The dog barks.

在上面的代码中，我们创建了一个 Dog 类的对象$dog。当我们在 $dog 对象上调用 makeSound（）方法时，它会输出“狗吠”，而不是父类中定义的通用声音。在编辑器中运行上述代码以获得更好、更清晰的解释。

此示例演示了方法重写如何允许我们自定义子类中继承方法的行为。通过为子类中的方法提供特定的实现，我们可以根据该类的独特特征对其进行定制。

让我们考虑另一个例子来说明在更实际的上下文中方法覆盖。假设我们有一个名为 Shape 的父类，其中包含一个计算形状面积的方法 calculateArea（）。我们想创建一个名为 Rectangle 的子类，该类使用其公式计算矩形的面积。

class Shape {
    public function calculateArea() {
        echo "Calculating area of a generic shape.";
    }
}

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

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

    public function calculateArea() {
        $area = $this->length * $this->width;
        echo "Area of the rectangle: ". $area;
    }
}

在上面的示例中，Rectangle 类扩展了 Shape 类并重写了 calculateArea（）方法。Rectangle 类具有自己的属性 $length 和 $width，用于定义矩形的尺寸。在重写方法中，我们使用提供的长度和宽度计算矩形的面积。在编辑器中运行上述代码以获得更好、更清晰的解释。

现在，让我们创建一个 Rectangle 类的对象并调用 calculateArea（）方法来查看被覆盖的行为。

$rectangle = new Rectangle(5, 10);
$rectangle->calculateArea(); // Output: Area of the rectangle: 50

在上面的代码中，我们创建了一个 Rectangle 类的对象$rectangle，将长度和宽度作为参数传递给构造函数。当我们在 $rectangle 对象上调用 calculateArea（）方法时，它使用 Rectangle 类中重写的实现计算并输出矩形的面积。在编辑器中运行上述代码以获得更好、更清晰的解释。

此示例演示了方法重写如何允许我们为特定子类提供专用行为。通过自定义继承方法的实现，我们可以确保它与子类的要求和特征保持一致。

分层继承

分层继承是面向对象编程中的一种继承，其中多个子类从单个父类继承。在此继承结构中，每个子类都从父类形成其单独的分支或层次结构。这允许创建具有特殊行为的不同子类，同时仍保留从父类继承的一组通用属性和方法。在本解释中，我们将探讨 PHP 中的分层继承。

为了理解分层继承，让我们考虑一个场景，其中有一个名为 Animal 的父类，它表示通用的动物行为。Animal 类定义与动物相关的常见属性和方法。

class Animal {
    protected $name;

    public function setName($name) {
        $this->name = $name;
    }

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

    public function eat() {
        echo "The animal is eating.";
    }

    public function sleep() {
        echo "The animal is sleeping.";
    }
}

现在，让我们创建两个子类，即 Dog 和 Cat，它们继承自 Animal 类。这些类将代表特定类型的动物，并且可以具有其独特的属性和方法。

class Dog extends Animal {
    public function bark() {
        echo "The dog is barking.";
    }
}

class Cat extends Animal {
    public function meow() {
        echo "The cat is meowing.";
    }
}

在上面的示例中，Dog 和 Cat 类使用 extends 关键字扩展 Animal 类。这将在父类 Animal 及其子类 Dog 和 Cat 之间建立层次结构关系。在编辑器中运行上述代码以获得更好、更清晰的解释。

现在，让我们创建 Dog 和 Cat 类的对象，并演示它们如何继承 Animal 类的属性和方法。

$dog = new Dog();
$dog->setName("Buddy");
echo $dog->getName(); // Output: Buddy
$dog->eat(); // Output: The animal is eating.
$dog->sleep(); // Output: The animal is sleeping.
$dog->bark(); // Output: The dog is barking.

$cat = new Cat();
$cat->setName("Whiskers");
echo $cat->getName(); // Output: Whiskers
$cat->eat(); // Output: The animal is eating.
$cat->sleep(); // Output: The animal is sleeping.
$cat->meow(); // Output: The cat is meowing.

在上面的代码中，我们分别创建 Dog 和 Cat 类的对象，$dog 和 $cat。由于子类继承自 Animal 类，因此它们可以访问和利用父类中定义的属性和方法。在编辑器中运行上述代码以获得更好、更清晰的解释。

Dog 和 Cat 对象都可以访问 name 属性以及 Animal 类中定义的 setName（）和 getName（）方法。此外，他们还可以从 Animal 类中调用 eat（）和 sleep（）方法。

此外，Dog 类引入了一个新方法 bark（），而 Cat 类引入了一个新方法 meow（）。这些方法对于其各自的子类是唯一的，并且不存在于父类中。

分层继承允许在类层次结构中创建不同的分支，每个子类都有其专用行为，同时共享父类的公共属性和方法。

继承和 UML

继承是面向对象编程中的一个基本概念，它允许一个类从另一个类（称为父类或基类）继承属性和方法。它促进了代码重用，并促进了类之间层次结构关系的创建。UML（统一建模语言）是一种标准化的图形符号，用于可视化和记录面向对象的系统。在本解释中，我们将讨论 PHP 的 UML 图中继承的表示。

在 UML 中，继承使用一条实线表示，箭头从子类指向父类。箭头指示继承方向，子类继承自父类。让我们考虑一个例子来说明这种表示形式。

假设我们有一个名为 Shape 的父类，它定义了几何形状的通用属性和方法。我们想要创建两个子类，即 Circle 和 Rectangle，它们继承自 Shape 类。下面是此继承关系的 UML 表示形式：

  +----------------+
  |     Shape      |
  +----------------+
             ^
             |
  +----------------+
  |     Circle     |
  +----------------+

  +----------------+
  |   Rectangle    |
  +----------------+

在上面的 UML 图中，Shape 类位于顶部，Circle 和 Rectangle 类位于其下方。箭头从“圆形”指向“形状”和“矩形”指向“形状”的实线表示继承关系。它指示 Circle 和 Rectangle 类都继承了 Shape 类的属性和方法。

此外，UML 允许我们使用特定的符号来表示继承关系的类型。UML 中常用的继承关系有三种类型：

泛化：
泛化表示子类从父类继承的继承关系。它由实线上未填充的箭头表示。泛化表示“is-a”关系，这意味着子类是父类的专用类型。在我们的示例中，Circle 和 Rectangle 与 Shape 具有泛化关系。
实现：
实现表示子类实现父类提供的接口的继承关系。它用带有箭头的虚线表示。实现表示子类履行父类指定的协定。但是，在不支持接口的PHP中，实现并不常用。
依赖关系：
依赖关系表示一个类依赖于另一个类的关系，但它不是继承关系。它用带有箭头的虚线表示。依赖项指示父类中的更改可能会影响子类。它代表了一种“使用”关系。

通过使用这些表示法，UML 图提供了 PHP 应用程序中类之间继承关系的可视化表示。它们有助于理解类层次结构、识别父子关系以及可视化代码组织。