Comprendre la programmation orientée objet (POO) en PHP

La programmation orientée objet (POO) est un paradigme de programmation fondé sur le concept d'« objets », qui regroupent des données (propriétés) et des comportements (méthodes) opérant sur ces données. Au lieu de disperser des variables et des fonctions liées à travers votre script, la POO vous permet de les regrouper en unités autonomes modélisant les entités de votre application — un User, une Order, un Product.

Ce chapitre couvre les deux fondements de la POO en PHP — les classes et les objets — puis présente les trois concepts que vous utiliserez au quotidien : l'encapsulation, l'héritage et le polymorphisme. À la fin, vous serez capable de lire et d'écrire des classes PHP avec assurance et de savoir quelle fonctionnalité résout quel problème.

Que sont les classes et les objets dans la POO PHP ?

Une classe est un plan directeur. Elle décrit quelles données un objet contient et ce qu'il peut faire, mais n'est pas une chose en elle-même — tout comme un plan architectural n'est pas une maison. Un objet est une instance concrète construite à partir de ce plan, créée avec le mot-clé new. Vous pouvez créer plusieurs objets à partir d'une même classe, chacun avec ses propres données.

Un bon moyen de le retenir : la classe est l'emporte-pièce, les objets sont les gâteaux. Les classes et les objets sont les blocs de construction de la POO en PHP.

Définir des classes en PHP

Les classes en PHP sont définies à l'aide du mot-clé class, suivi du nom de la classe. Les propriétés et méthodes d'une classe sont définies à l'intérieur de sa définition, entre accolades ({}). Voici un exemple de définition de classe en PHP :

Exemple de définition d'une classe en PHP

class User {
    public $username;
    public $email;
    public function __construct($username, $email) {
        $this->username = $username;
        $this->email = $email;
    }
    public function getUsername() {
        return $this->username;
    }
    public function getEmail() {
        return $this->email;
    }
}

Dans cet exemple, la classe User possède deux propriétés, $username et $email, ainsi que deux méthodes, getUsername() et getEmail(). La méthode __construct est une méthode constructeur spéciale en PHP : elle s'exécute automatiquement dès qu'un objet est créé, ce qui en fait l'endroit naturel pour initialiser l'état d'un objet. À l'intérieur de toute méthode, $this fait référence à l'objet courant, donc $this->username signifie « la propriété username de cet objet ». Pour en savoir plus sur les constructeurs et la méthode de nettoyage associée, consultez PHP Constructor et PHP Destructor.

Créer des objets à partir de classes

Pour créer un objet à partir d'une classe, utilisez le mot-clé new, suivi du nom de la classe. Voici un exemple de création d'un objet à partir de la classe User :

Créer un objet à partir d'une classe en PHP avec le mot-clé new

$user = new User("John Doe", "[email protected]");

Cela crée un nouvel objet User et le stocke dans la variable $user. Vous pouvez accéder aux propriétés et méthodes de l'objet à l'aide de l'opérateur flèche (->). Voici un exemple d'accès aux propriétés et méthodes de l'objet $user :

Accéder aux propriétés et méthodes de l'objet avec l'opérateur flèche en PHP

echo $user->username; // Outputs: "John Doe"
echo $user->email; // Outputs: "[email protected]"
echo $user->getUsername(); // Outputs: "John Doe"
echo $user->getEmail(); // Outputs: "[email protected]"

Encapsulation : contrôler l'accès aux données

Dans les exemples précédents, chaque propriété est déclarée public, ce qui signifie que n'importe quel code peut la lire ou la modifier directement ($user->email = "..."). C'est pratique, mais risqué — cela permet au reste de votre programme de placer un objet dans un état invalide. L'encapsulation est la pratique consistant à masquer les détails internes d'un objet et à exposer une interface contrôlée à la place.

PHP fournit trois modificateurs de visibilité pour les propriétés et les méthodes :

En rendant une propriété private et en exposant des méthodes pour la lire ou la modifier, vous centralisez la validation au même endroit :

<?php

class BankAccount
{
    private $balance = 0;

    public function deposit($amount)
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException("Deposit must be positive.");
        }
        $this->balance += $amount;
    }

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

$account = new BankAccount();
$account->deposit(100);
$account->deposit(50);
echo $account->getBalance(); // Outputs: 150

Comme $balance est private, aucun code extérieur ne peut lui attribuer directement une valeur négative — chaque modification doit passer par deposit(), où la règle est définie. Pour une étude approfondie des trois mots-clés, lisez PHP Access Modifiers.

Héritage dans la POO PHP

L'héritage est une fonctionnalité de la POO qui permet aux classes d'hériter des propriétés et méthodes de classes parentes. Cela permet aux développeurs de créer de nouvelles classes basées sur des classes existantes, sans avoir à réécrire tout le code. En PHP, l'héritage est défini à l'aide du mot-clé extends. Voici un exemple d'héritage en PHP :

Exemple PHP d'héritage, une fonctionnalité de la POO permettant aux classes d'hériter

class Admin extends User {
    public $permissions;
    public function __construct($username, $email, $permissions) {
        parent::__construct($username, $email);
        $this->permissions = $permissions;
    }
    public function getPermissions() {
       return $this->permissions;
   }
}

Dans cet exemple, la classe Admin étend la classe User et hérite de ses propriétés et méthodes. La classe Admin possède également sa propre propriété, $permissions, et sa propre méthode, getPermissions(). Le mot-clé parent:: est utilisé pour appeler la méthode __construct de la classe parente, permettant à la classe Admin de réutiliser la logique de la classe User sans la dupliquer. Une classe ne peut étendre qu'un seul parent en PHP. Pour une vue d'ensemble complète, consultez PHP Inheritance.

Polymorphisme dans la POO PHP

Le polymorphisme est une fonctionnalité de la POO qui permet de traiter des objets de classes différentes comme des objets d'une même classe. Cela permet aux développeurs d'écrire du code générique pouvant fonctionner avec des objets de classes différentes, à condition qu'ils aient les mêmes méthodes. En PHP, le polymorphisme est réalisé en définissant des méthodes communes dans les classes parentes et en les implémentant dans les classes enfants. Voici un exemple de polymorphisme en PHP :

Exemple de polymorphisme en PHP

<?php

class User
{
    public $username;
    public $email;

    public function __construct($username, $email)
    {
        $this->username = $username;
        $this->email = $email;
    }
    public function getUsername()
    {
        return $this->username;
    }
    public function getEmail()
    {
        return $this->email;
    }

    public function showInfo()
    {
        echo "Username: " . $this->username . "\n";
        echo "Email: " . $this->email . "\n";
    }
}

class Admin extends User
{
    public $permissions;
    public function __construct($username, $email, $permissions)
    {
        parent::__construct($username, $email);
        $this->permissions = $permissions;
    }
    public function getPermissions()
    {
        return $this->permissions;
    }

    public function showInfo()
    {
        parent::showInfo();
        echo "Permissions: " . $this->permissions . "\n";
    }
}

$user = new User("John Doe", "[email protected]");
$admin = new Admin("Jane Doe", "[email protected]", ["read", "write", "delete"]);

$users = [$user, $admin];

foreach ($users as $user) {
    $user->showInfo();
}

Dans cet exemple, la classe User et la classe Admin ont toutes deux une méthode showInfo(). Lorsque la méthode showInfo() est appelée sur un objet, la bonne implémentation de la méthode est invoquée en fonction du type de l'objet. Cela permet à la boucle foreach de traiter les objets $user et $admin comme des objets du même type, même s'ils sont des instances de classes différentes.

Conclusion

La programmation orientée objet (POO) est un paradigme puissant largement utilisé en PHP pour créer des applications web évolutives et maintenables. Les classes et les objets en sont les blocs de construction ; l'encapsulation, l'héritage et le polymorphisme sont les fonctionnalités qui vous permettent d'écrire du code efficace et réutilisable. Maîtrisez ces concepts et le reste du modèle objet PHP s'articulera naturellement.

Où aller ensuite :

• PHP Constructor — initialiser correctement les objets.
• PHP Access Modifiers — public, protected et private en profondeur.
• PHP Inheritance — étendre et redéfinir des classes.
• PHP Abstract Classes — définir des plans partiels que les sous-classes doivent compléter.
• PHP Interfaces — imposer un contrat commun à des classes non liées.
• PHP Static Methods — méthodes appartenant à la classe plutôt qu'à une instance.

Practice