Comment utiliser l'héritage, le polymorphisme et les interfaces en PHP

PHP est un langage de script open source utilisé pour la programmation côté serveur et est devenu l'un des langages de programmation les plus populaires et les plus utilisés au monde. En PHP, l'héritage, le polymorphisme et les interfaces sont trois concepts importants de programmation orientée objet qui permettent aux développeurs de bénéficier de grands avantages en termes de réutilisation, de flexibilité et de maintenabilité du code. Cet article approfondira ces trois concepts et présentera comment les utiliser en PHP.

1. Héritage

L'héritage est l'un des concepts les plus fondamentaux de la programmation orientée objet. Cela signifie qu'une classe peut hériter des propriétés et méthodes d'une autre classe et ajouter des propriétés et méthodes personnalisées sur cette base. Le sous-classement est obtenu en étendant une classe parent (également appelée superclasse ou classe de base), permettant à la sous-classe de réutiliser le code et les fonctionnalités de la classe parent.

En PHP, l'héritage se fait en utilisant le mot clé "extends". Par exemple, le code suivant est une implémentation d'héritage simple :

class Person {
  // 定义一个方法
  public function sayHello() {
    echo "Hello, world!";
  }
}

class Student extends Person {
  // 定义一个新的方法
  public function sayGoodbye() {
    echo "Goodbye, world!";
  }
}

// 使用子类的对象
$student = new Student();
$student->sayHello();  // 输出 “Hello, world!”
$student->sayGoodbye();  // 输出 “Goodbye, world!”

Dans cet exemple, nous définissons une classe nommée Person et y définissons une méthode nommée sayHello(). Nous avons ensuite créé une sous-classe appelée Student et l'avons étendue à la classe Person à l'aide du mot-clé « extends ». Dans la sous-classe, nous avons ajouté une nouvelle méthode appelée sayGoodbye(). Enfin, nous créons une instance de la classe Student nommée $student et appelons ses méthodes.

Il est à noter que lorsqu'une sous-classe hérite d'une classe parent, elle peut non seulement hériter de ses propriétés et méthodes, mais également accéder à des propriétés et méthodes non privées. En fait, pour les propriétés et méthodes privées, les sous-classes ne peuvent pas y accéder même après avoir hérité de la classe parent.

2. Polymorphisme

Le polymorphisme est un autre concept clé de programmation orientée objet qui fait référence aux mêmes méthodes qui peuvent présenter des comportements différents. Les méthodes avec polymorphisme peuvent déterminer automatiquement la méthode réelle qui doit être appelée au moment de l'exécution, ce qui améliore considérablement la flexibilité et l'évolutivité du programme.

En PHP, la manière d'atteindre le polymorphisme est d'utiliser les mots-clés "abstrait" et "interface". Nous pouvons réaliser le polymorphisme en définissant des classes ou des interfaces abstraites et en héritant de classes abstraites ou en implémentant des interfaces.

2.1 Classe abstraite

Une classe abstraite est une classe qui ne peut pas être instanciée et ne peut être héritée qu'en tant que super classe d'autres classes. Une classe abstraite peut définir certaines méthodes abstraites, qui doivent être implémentées dans ses sous-classes. De cette façon, nous pouvons réaliser le polymorphisme grâce à des classes abstraites.

Ce qui suit est un exemple d'utilisation de classes abstraites pour obtenir un polymorphisme :

abstract class Shape {
  // 定义一个抽象方法
  abstract public function getArea();
}

class Circle extends Shape {
  private $radius;

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

  // 实现抽象方法
  public function getArea() {
    return pi() * pow($this->radius, 2);
  }
}

class Square extends Shape {
  private $side;

  public function __construct($side) {
    $this->side = $side;
  }
  
  // 实现抽象方法
  public function getArea() {
    return pow($this->side, 2);
  }
}

// 创建一个圆
$circle = new Circle(2);
// 创建一个正方形
$square = new Square(2);

// 输出面积
echo $circle->getArea();  // 输出 "12.566370614359"
echo $square->getArea();  // 输出 "4"

Dans cet exemple, nous définissons une classe abstraite Shape et déclarons une méthode appelée méthode abstraite getArea() . Ensuite, nous avons créé deux sous-classes, Circle et Square, et implémenté respectivement la méthode getArea(). Enfin, nous créons des instances d’un cercle et d’un carré et appelons leurs méthodes getArea().

2.2 Interface

Une interface est un type abstrait qui définit un ensemble de signatures de méthodes (mais n'implémente pas ces méthodes). Une classe peut implémenter cette interface pour représenter l'interface. Un engagement envers un comportement défini. De cette façon, nous pouvons également réaliser le polymorphisme via les interfaces. En PHP, on peut utiliser le mot-clé "interface" pour définir l'interface et le mot-clé "implements" pour implémenter l'interface.

Ce qui suit est un exemple d'utilisation d'interfaces pour obtenir un polymorphisme :

interface Animal {
  public function makeSound();
}

class Dog implements Animal {
  public function makeSound() {
    echo "Woof!";
  }
}

class Cat implements Animal {
  public function makeSound() {
    echo "Meow!";
  }
}

// 创建一个狗
$dog = new Dog();
// 创建一只猫
$cat = new Cat();

// 输出声音
$dog->makeSound();  // 输出 "Woof!"
$cat->makeSound();  // 输出 "Meow!"

Dans cet exemple, nous définissons une interface Animal et déclarons une interface appelée méthode makeSound(). Ensuite, nous avons créé deux sous-classes Dog et Cat qui implémentaient respectivement l'interface Animal et la méthode makeSound(). Enfin, nous créons des instances d'un chien et d'un chat et appelons leurs méthodes makeSound().

Il est à noter que les interfaces ne peuvent définir que des méthodes abstraites, et ces méthodes doivent être implémentées par les classes qui implémentent l'interface.

3. Summary

L'héritage, le polymorphisme et l'interface sont trois concepts importants de programmation orientée objet, qui sont également largement utilisés en PHP. Grâce à l'héritage, nous pouvons laisser une classe hériter des propriétés et des méthodes d'une autre classe et ajouter des propriétés et des méthodes personnalisées par-dessus cela. Grâce au polymorphisme, nous pouvons appeler des méthodes avec des comportements différents via le même nom de méthode dans différentes situations. À l’aide d’une interface, vous pouvez définir un ensemble de signatures de méthodes et faire implémenter ces méthodes par les classes qui implémentent l’interface.

Lorsque nous écrivons des programmes PHP orientés objet, une utilisation raisonnable des trois concepts d'héritage, de polymorphisme et d'interfaces peut rendre nos programmes plus flexibles, évolutifs et plus faciles à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!