Comprendre la programmation orientée objet en PHP

La programmation orientée objet (POO) est une façon de structurer le code autour d'objets — des unités autonomes qui regroupent des données (appelées propriétés) et le comportement qui agit sur ces données (appelées méthodes). Au lieu d'écrire une longue liste de fonctions qui se transmettent des données, vous modélisez les éléments de votre domaine (un utilisateur, une commande, une connexion à une base de données) sous forme d'objets qui gèrent leur propre état.

PHP prend en charge la POO depuis PHP 5, et les frameworks PHP modernes tels que Laravel et Symfony sont construits presque entièrement dessus. Ce chapitre explique ce qu'est la POO, pourquoi elle existe et comment les concepts fondamentaux se traduisent en syntaxe PHP. À la fin, vous connaîtrez la différence entre une classe et un objet, et vous reconnaîtrez les quatre piliers de la POO : l'encapsulation, l'héritage, le polymorphisme et l'abstraction.

PHP procédural vs. orienté objet

Avant les classes, le code PHP était typiquement procédural — une séquence d'instructions et de fonctions opérant sur des variables simples :

$carMake = "Ford";
$carModel = "Mustang";

function describeCar($make, $model) {
  return "The car is a $make $model.";
}

echo describeCar($carMake, $carModel);
// The car is a Ford Mustang.

Cela fonctionne, mais les données ($carMake, $carModel) et la fonction qui les utilise sont faiblement liées. Au fur et à mesure qu'un projet grandit, il devient difficile de savoir quelles fonctions appartiennent à quelles données. La POO résout ce problème en regroupant les données et le comportement dans une seule classe.

Classes et objets

Les deux concepts fondamentaux de la POO sont la classe et l'objet :

• Une classe est un plan directeur. Elle décrit les propriétés et méthodes qu'un objet aura, mais ce n'est pas une valeur que vous pouvez utiliser directement — comme un plan architectural pour une maison.
• Un objet est une instance concrète créée à partir de ce plan directeur, avec de vraies valeurs renseignées — comme une maison réelle construite d'après le plan.

En PHP, vous déclarez une classe avec le mot-clé class et créez un objet à partir d'elle avec l'opérateur new :

class Car {
  public $make;
  public $model;
}

$car = new Car();   // $car is an object (an instance of Car)
$car->make = "Ford";
$car->model = "Mustang";

echo $car->make;    // Ford

Vous pouvez créer autant d'objets indépendants à partir d'une classe que nécessaire, et chacun conserve sa propre copie des propriétés. L'opérateur flèche -> accède à une propriété ou une méthode d'un objet. En savoir plus sur les Classes et objets PHP.

Les quatre piliers de la POO

La POO repose sur quatre principes fondamentaux. PHP vous offre une fonctionnalité de langage dédiée pour chacun d'eux.

Encapsulation

L'encapsulation signifie regrouper les données d'un objet et les méthodes qui les modifient, tout en contrôlant l'accès depuis l'extérieur. En marquant les propriétés private et en les exposant uniquement via des méthodes, vous protégez un objet contre les états invalides.

class BankAccount {
  private $balance = 0;

  public function deposit($amount) {
    if ($amount > 0) {
      $this->balance += $amount;
    }
  }

  public function getBalance() {
    return $this->balance;
  }
}

$account = new BankAccount();
$account->deposit(100);
echo $account->getBalance();   // 100

Ici, $balance ne peut pas être défini directement à une valeur absurde — chaque modification passe par deposit(), qui valide l'entrée.

Héritage

L'héritage permet à une classe de réutiliser les propriétés et méthodes d'une autre. Une classe enfant déclarée avec extends hérite automatiquement de tout ce que possède sa classe parente et peut y ajouter des éléments ou les remplacer. Cela évite de dupliquer du code partagé. Consultez l'héritage PHP pour plus de détails.

class Vehicle {
  public function start() {
    return "Engine started.";
  }
}

class Car extends Vehicle {
  public function openTrunk() {
    return "Trunk opened.";
  }
}

$car = new Car();
echo $car->start();        // Engine started.  (inherited)
echo $car->openTrunk();    // Trunk opened.     (its own)

Polymorphisme

Le polymorphisme ("plusieurs formes") signifie que différentes classes peuvent répondre au même appel de méthode à leur manière. Le code qui appelle makeSound() n'a pas besoin de savoir s'il tient un Dog ou un Cat :

class Dog {
  public function makeSound() { return "Woof"; }
}

class Cat {
  public function makeSound() { return "Meow"; }
}

foreach ([new Dog(), new Cat()] as $animal) {
  echo $animal->makeSound() . "\n";
}
// Woof
// Meow

C'est particulièrement puissant lorsque combiné avec les interfaces, qui garantissent que chaque classe fournit le même ensemble de méthodes.

Abstraction

L'abstraction signifie masquer les détails d'implémentation derrière une interface simple et bien définie. Les utilisateurs d'une classe travaillent avec ce qu'elle fait, et non comment elle le fait. PHP prend cela en charge via les classes abstraites et les interfaces, qui définissent des signatures de méthodes sans implémentation (ou avec une implémentation partielle).

Tout assembler : un exemple complet

La classe ci-dessous combine des propriétés, un constructeur qui s'exécute automatiquement lors de la création de l'objet, et une méthode :

class Car {
  public $color;
  public $make;
  public $model;

  function __construct($color, $make, $model) {
    $this->color = $color;
    $this->make  = $make;
    $this->model = $model;
  }

  function getDescription() {
    return "The car is a " . $this->make . " " . $this->model . " in " . $this->color . " color.";
  }
}

$car = new Car("red", "Ford", "Mustang");
echo $car->getDescription();
// The car is a Ford Mustang in red color.

Ce qui se passe ici :

• La classe Car déclare trois propriétés publiques — color, make et model.
• __construct() est une méthode spéciale que PHP appelle au moment où new Car(...) s'exécute. Elle copie les arguments dans les propriétés de l'objet à l'aide de $this, qui fait toujours référence à l'objet courant.
• getDescription() lit ces propriétés et retourne une phrase.
• new Car("red", "Ford", "Mustang") construit l'objet ; l'appel à $car->getDescription() produit la sortie affichée dans le commentaire.

Quand utiliser la POO ?

La POO est particulièrement adaptée lorsqu'une application comporte de nombreux concepts liés avec leurs propres données et comportements, lorsque vous souhaitez réutiliser du code dans un projet, ou lorsque vous travaillez avec un framework qui l'exige. Pour un petit script ponctuel, les fonctions procédurales simples peuvent être plus appropriées. La plupart du PHP en production — APIs, applications web, bibliothèques — s'appuie sur la POO car elle permet de garder les bases de code croissantes organisées et testables.

Conclusion

La programmation orientée objet organise le code autour d'objets qui regroupent données et comportement. Vous définissez une classe comme plan directeur et créez des objets à partir d'elle avec new. Les quatre piliers — encapsulation, héritage, polymorphisme et abstraction — vous donnent les outils pour protéger les données, réutiliser le code et maintenir les grandes applications.

Pour aller plus loin, continuez avec les Classes et objets PHP, puis explorez l'héritage, les interfaces, les classes abstraites et les traits.

Pratique