Analyse orientée objet PHP: un guide pratique de l'héritage et du polymorphisme

Comprendre l'héritage en php

L'héritage est un mécanisme important pour la programmation orientée objet. Il permet à une classe de créer de nouvelles classes en fonction d'une autre classe, et les sous-classes peuvent hériter des propriétés et des méthodes de la classe parent, implémentant ainsi la réutilisation et l'extension de code. Dans PHP, le mot-clé s'étend est utilisé pour créer des sous-classes, tandis que Parent :: est utilisé pour appeler des méthodes ou des propriétés des membres de la classe parent.

Exemple de code hérité

 class Animal {
   protected $name;
   protected $age;

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

   public function getInfo() {
      return "Name: " . $this->name . ", Age: " . $this->age;
   }
}

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

$dog = new Dog("Rex", 3);
echo $dog->getInfo();  // Sortir "Name: Rex, Age: 3"
echo $dog->bark();     // Sortir "Woof!"

Le code ci-dessus montre un animal de classe de base d'animaux, qui a des attributs et des méthodes de nom et d'âge pour obtenir des informations. Le chien de sous-classe hérite de ces propriétés et méthodes, et ajoute la méthode d'écorce () , reflétant l'utilisation de base de l'héritage.

Comment implémenter le polymorphisme PHP

Le polymorphisme fait référence à la même interface ou méthode montrant différents comportements dans différents types d'objets. Dans PHP, le polymorphisme est principalement mis en œuvre par les interfaces et la classe abstraite. L'interface définit la spécification de la méthode, tandis que la classe abstraite fournit des implémentations partielles, et la sous-classe doit implémenter la méthode abstraite en détail. Cela rend le code plus flexible et évolutif.

Exemple polymorphe: interface et classe d'implémentation

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

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

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

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

   public function perimeter() {
      return 2 * ($this->length + $this->width);
   }
}

class Circle implements Shape {
   private $radius;

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

   public function area() {
      return pi() * pow($this->radius, 2);
   }

   public function perimeter() {
      return 2 * pi() * $this->radius;
   }
}

$rectangle = new Rectangle(5, 3);
$circle = new Circle(2);

echo $rectangle->area();     // Sortir 15
echo $rectangle->perimeter();  // Sortir 16

echo $circle->area();        // Sortir 12.566370614359
echo $circle->perimeter();   // Sortir 12.566370614359

Dans l'exemple, les interfaces de forme d'implémentation rectangulaire et de cercle , et les méthodes de zone () et de périmètre () doivent être définies. Différentes implémentations font que la même méthode a des comportements différents, qui est la manifestation du polymorphisme.

Résumer

L'héritage et le polymorphisme sont à la base de la programmation orientée objet PHP. La maîtrise de ces deux peut améliorer considérablement l'organisation et la réutilisabilité du code. L'héritage permet aux sous-classes d'obtenir les propriétés et les méthodes de la classe parent pour éviter le code en double; Le polymorphisme permet à la même méthode de montrer divers comportements dans différents objets via des interfaces ou des classes abstraites, améliorant ainsi la flexibilité du code. L'exemple de code fourni dans cet article convient aux débutants pour comprendre ces concepts et aider à développer des programmes PHP de meilleure qualité.