L'héritage en PHP

Bienvenue dans la prochaine leçon ! Vous allez découvrir l'héritage, un concept fondamental de la programmation orientée objet (POO) qui permet d'étendre les fonctionnalités d'une classe. Commençons !

Qu'est-ce que l'héritage ?

L'héritage est un mécanisme de la POO qui permet à une classe (classe enfant) d'hériter des propriétés et des méthodes d'une autre classe (classe parente). Il favorise la réutilisation du code et établit une hiérarchie en programmation.

Exemple : Une classe Car peut servir de classe parente aux classes Sedan et SUV.

Définir l'héritage

Utilisez le mot-clé extends pour créer une classe enfant qui hérite d'une classe parente. Exemple :

Conseil : Utilisez l'héritage pour éviter de dupliquer le code.

<h2>Defining Inheritance</h2>
<p>Use the <code>extends</code> keyword to create a child class that inherits from a parent class. Example:</p>

Redéfinir des méthodes

Les classes enfants peuvent redéfinir les méthodes de la classe parente afin de fournir une fonctionnalité spécifique. Exemple :

<?php
  class Vehicle {
    public function drive() {
      echo "Driving a generic vehicle.";
    }
  }

  class Car extends Vehicle {
    public function drive() {
      echo "Driving a car.";
    }
  }

  $car = new Car();
  $car->drive(); // Outputs: Driving a car.
?>

Le mot-clé parent

Utilisez le mot-clé parent pour appeler une méthode de la classe parente au sein d'une méthode redéfinie. Exemple :

<?php
  class Vehicle {
    public function start() {
      echo "Starting the vehicle.";
    }
  }

  class Car extends Vehicle {
    public function start() {
      parent::start();
      echo " Starting the car engine.";
    }
  }

  $car = new Car();
  $car->start(); // Outputs: Starting the vehicle. Starting the car engine.
?>

Avantages de l'héritage

L'héritage offre les avantages suivants :

• Il favorise la réutilisation du code.
• Il établit une hiérarchie claire entre les classes.
• Il permet le polymorphisme en autorisant les classes enfants à redéfinir des méthodes.

Membres protégés

L'héritage fonctionne également avec les membres protégés. Les propriétés et les méthodes protégées sont accessibles aux classes enfants, mais pas en dehors de la hiérarchie de classes. Exemple :

Point essentiel : Utilisez protected pour partager des membres entre les classes parentes et enfants de manière sécurisée.

<?php
  class Vehicle {
    protected $fuel;

    public function setFuel($fuel) {
      $this->fuel = $fuel;
    }
  }

  class Car extends Vehicle {
    public function getFuel() {
      return $this->fuel;
    }
  }

  $car = new Car();
  $car->setFuel("Gasoline");
  echo "Fuel: " . $car->getFuel(); // Outputs: Fuel: Gasoline
?>

Classes abstraites

Une classe abstraite fournit une structure de base aux classes enfants, mais ne peut pas être instanciée elle-même. Exemple :

Point essentiel : Utilisez des classes abstraites lorsque vous souhaitez imposer certaines méthodes aux classes enfants.

<?php
  abstract class Vehicle {
    abstract public function start();
  }

  class Car extends Vehicle {
    public function start() {
      echo "Starting the car engine.";
    }
  }

  $car = new Car();
  $car->start(); // Outputs: Starting the car engine.
?>

Mot-clé final

Le mot-clé final empêche tout nouvel héritage ou toute redéfinition. Exemple :

Conseil : Utilisez final pour protéger des méthodes ou des classes contre toute extension.

<?php
  class Vehicle {
    final public function start() {
      echo "Starting the vehicle.";
    }
  }

  class Car extends Vehicle {
    // Cannot override the start method
  }
?>

Excellent travail !

Félicitations ! Vous avez découvert l'héritage en PHP, notamment comment étendre des classes, redéfinir des méthodes et utiliser des classes abstraites. Dans la prochaine leçon, nous explorerons l'encapsulation et les modificateurs d'accès. Poursuivons notre apprentissage du code !