Public, Private, Protected en PHP : le guide complet de l'encapsulation

Public, Private, Protected en PHP : pourquoi votre code a besoin de ces garde-fous ?

Imaginez que vous construisez une maison. Vous avez une porte d'entrée (tout le monde peut entrer), une chambre avec un verrou (réservée à la famille) et un coffre-fort dans le mur (accessible uniquement par vous). Dans le monde de la programmation orientée objet (POO) en PHP, ces « portes » et « verrous » s'appellent des modificateurs d'accès.

Si vous avez déjà écrit des classes en PHP, vous avez forcément croisé les mots public, private et protected. Mais que signifient-ils vraiment ? Pourquoi ne pas tout mettre en public et vivre tranquille ? La réponse est simple : sans eux, votre code devient un hall de gare, où n'importe quel script peut accidentellement casser la logique de votre programme.

Dans cet article, nous allons décortiquer les modificateurs d'accès en PHP avec des exemples concrets, comprendre leurs différences et apprendre à les utiliser pour créer un code robuste et flexible. Ce guide s'inspire d'une question populaire sur Stack Overflow et est adapté pour le site éducatif pythonlib.ru.

Que sont les modificateurs d'accès et pourquoi sont-ils essentiels ?

Les modificateurs d'accès sont des mots-clés qui définissent d'où l'on peut accéder aux propriétés et méthodes d'une classe. Ils sont le fondement de l'encapsulation (l'un des quatre piliers de la POO). L'encapsulation cache le fonctionnement interne d'un objet et protège les données contre une utilisation incorrecte.

En PHP, il existe trois niveaux d'accès :

\n
• Public — accessible partout (à l'intérieur comme à l'extérieur de la classe).
\n
• Private — accessible uniquement à l'intérieur de la classe elle-même.
\n
• Protected — accessible dans la classe et dans les classes qui en héritent.
\n

Examinons chacun d'eux avec des exemples pratiques.

Public : « Entrée libre »

Le modificateur public est le plus ouvert. Les propriétés et méthodes déclarées comme public peuvent être lues et modifiées de n'importe où : depuis une autre classe, depuis un script global, depuis la lune (je plaisante).

<?php\nclass Voiture {\n    public $marque = 'Toyota';\n\n    public function klaxonner() {\n        return 'Beep!';\n    }\n}\n\n$maVoiture = new Voiture();\necho $maVoiture->marque; // Toyota — fonctionne\n$maVoiture->marque = 'Honda'; // On modifie — fonctionne\necho $maVoiture->klaxonner(); // Beep!\n?>

Pratique, non ? Mais il y a un problème. Imaginez que la classe Utilisateur ait une propriété public $motDePasse. N'importe quel code extérieur pourrait la lire et la modifier. Une catastrophe pour la sécurité.

Quand l'utiliser : pour les méthodes qui font partie de l'API publique de la classe (par exemple, getNomUtilisateur()), ou pour les constantes.

Private : « Le coffre-fort incassable »

Le modificateur private est l'exact opposé de public. Une propriété ou une méthode est accessible uniquement à l'intérieur de la classe où elle est déclarée. Même les classes qui héritent ne voient pas les membres private du parent.

<?php\nclass CompteBancaire {\n    private $solde = 1000;\n\n    private function calculerInterets() {\n        return $this->solde * 0.05;\n    }\n\n    public function getSolde() {\n        return $this->solde;\n    }\n\n    public function appliquerInterets() {\n        $this->solde += $this->calculerInterets();\n    }\n}\n\n$compte = new CompteBancaire();\n// echo $compte->solde; // Erreur ! Impossible d'accéder à une propriété private\n// echo $compte->calculerInterets(); // Erreur ! Impossible d'accéder à une méthode private\necho $compte->getSolde(); // 1000 — fonctionne car la méthode est public\n$compte->appliquerInterets();\necho $compte->getSolde(); // 1050\n?>

Dans cet exemple, $solde et calculerInterets() sont cachés du monde extérieur. Nous gérons le solde uniquement via les méthodes publiques getSolde() et appliquerInterets(). C'est cela, l'encapsulation.