Modificateurs d'accès PHP OOP : Guide complet

Les modificateurs d'accès (également appelés mots-clés de visibilité) déterminent qui est autorisé à lire, modifier ou appeler un membre d'une classe. Ils constituent le mécanisme qui sous-tend l'encapsulation — l'une des idées fondamentales de la Programmation Orientée Objet : vous exposez une surface publique petite et sécurisée tout en cachant les détails internes que les appelants ne devraient pas toucher.

Ce chapitre couvre les trois mots-clés de visibilité PHP — public, protected et private — ce que chacun autorise, ce qui se passe lorsque vous enfreignez les règles, comment la visibilité se comporte sous héritage, et les patrons courants (getters, setters et promotion de constructeur) qui s'appuient sur eux. Si les classes sont nouvelles pour vous, lisez d'abord Classes et objets PHP.

Les trois modificateurs d'accès en un coup d'œil

Vous pouvez appliquer un modificateur aux propriétés, méthodes et constantes de classe. Si vous omettez le modificateur sur une méthode, PHP le définit par défaut à public ; sur une propriété, vous devez en écrire un explicitement (l'ancien mot-clé var est un alias pour public).

Modificateur d'accès public

public est le niveau le plus permissif. Un membre public est accessible de partout — à l'intérieur de la classe, depuis les classes enfants, et depuis n'importe quel code détenant l'objet. Utilisez-le pour l'interface prévue de votre classe : les méthodes que les appelants sont censés utiliser.

<?php
class User {
  public $name;

  public function setName($name) {
    $this->name = $name;
  }

  public function getName() {
    return $this->name;
  }
}

$user = new User();
$user->setName("Ada");      // calling a public method
echo $user->getName();      // Ada
echo "\n";
$user->name = "Grace";      // touching a public property directly
echo $user->name;           // Grace

Le résultat est :

Ada
Grace

Étant donné que $name est public, les appelants peuvent le modifier directement avec $user->name = ..., en contournant setName(). C'est exactement pourquoi les propriétés publiques sont souvent déconseillées : vous perdez la possibilité de valider la valeur. Marquer la propriété protected ou private et l'exposer à travers des méthodes rétablit ce contrôle.

Modificateur d'accès protected

protected se situe au milieu. Le membre est accessible depuis l'intérieur de la classe et depuis n'importe quelle sous-classe, mais pas depuis le code extérieur. Utilisez-le lorsqu'une sous-classe a légitimement besoin des données, mais que les appelants externes ne devraient pas y accéder.

<?php
class User {
  protected $email;

  protected function setEmail($email) {
    $this->email = $email;
  }

  public function getEmail() {
    return $this->email;
  }
}

$user = new User();
echo $user->getEmail();   // works: getEmail() is public
$user->setEmail("[email protected]"); // Fatal error: Call to protected method User::setEmail()

L'exécution de ce code n'affiche rien pour la première ligne (l'email est encore null) et s'arrête ensuite avec :

PHP Fatal error:  Uncaught Error: Call to protected method User::setEmail() from global scope

L'erreur est intentionnelle : les membres protégés protègent la classe contre toute utilisation abusive par le code extérieur, tout en coopérant avec la chaîne d'héritage présentée ci-dessous.

Modificateur d'accès private

private est le niveau le plus restrictif. Le membre est visible uniquement à l'intérieur de la classe qui le déclare — même les sous-classes ne peuvent pas le voir. Utilisez private lorsqu'un détail est purement interne et pourrait changer à tout moment, comme un hachage de mot de passe ou un calcul mis en cache.

<?php
class User {
  private $password;

  public function setPassword($password) {
    // hide the real value behind validation
    $this->password = password_hash($password, PASSWORD_DEFAULT);
  }

  public function check($attempt) {
    return password_verify($attempt, $this->password);
  }
}

$user = new User();
$user->setPassword("s3cret");
var_dump($user->check("s3cret"));  // bool(true)
var_dump($user->check("wrong"));   // bool(false)

Le résultat est :

bool(true)
bool(false)

Tenter de lire $user->password depuis l'extérieur de la classe génère Error: Cannot access private property User::$password. L'appelant ne peut interagir qu'à travers les méthodes publiques setPassword() et check() — le hachage brut est scellé.

Modificateurs d'accès et héritage

Lorsqu'une classe enfant étend un parent, elle hérite des membres du parent avec leur visibilité. Les membres public et protected sont utilisables à l'intérieur de l'enfant ; les membres private ne sont pas visibles par l'enfant du tout.

<?php
class User {
  protected $email;

  protected function setEmail($email) {
    $this->email = $email;
  }

  public function getEmail() {
    return $this->email;
  }
}

class Admin extends User {
  // Admin can call the protected setEmail() because it is a subclass
  public function updateEmail($email) {
    $this->setEmail($email);
  }
}

$admin = new Admin();
$admin->updateEmail("[email protected]");
echo $admin->getEmail();   // [email protected]

Le résultat est :

[email protected]

Un enfant peut également élargir la visibilité (protected → public) lors de la redéfinition d'un membre, mais il ne peut pas la restreindre — redéfinir une méthode publique en private déclenche une erreur fatale. Pour plus d'informations sur la construction des hiérarchies de classes, consultez Héritage PHP.

Visibilité sur les constantes et la promotion de constructeur

Les constantes de classe acceptent les mêmes modificateurs (depuis PHP 7.1). Cela vous permet d'exposer certaines constantes tout en cachant les valeurs de paramétrage :

<?php
class Order {
  public const STATUS_PAID = "paid";
  private const TAX_RATE = 0.2;   // internal detail

  public function total(float $net): float {
    return $net * (1 + self::TAX_RATE);
  }
}

echo Order::STATUS_PAID;            // paid
echo "\n";
echo (new Order())->total(100);    // 120

Le résultat est :

paid
120

Depuis PHP 8.0, la promotion de propriété de constructeur vous permet de déclarer une propriété et sa visibilité directement dans la signature du constructeur, supprimant le code répétitif :

<?php
class Point {
  public function __construct(
    public int $x = 0,
    private int $y = 0,   // declared, assigned, and made private in one line
  ) {}

  public function describe(): string {
    return "x={$this->x}, y={$this->y}";
  }
}

echo (new Point(3, 4))->describe();  // x=3, y=4

Le résultat est :

x=3, y=4

Consultez Constantes de classe PHP et Constructeur PHP pour une vue complète de ces fonctionnalités.

Choisir le bon modificateur

• Commencez par le niveau le plus restrictif (private) et assouplissez uniquement lorsqu'un besoin réel apparaît. Cela maintient votre API publique petite et facile à modifier ultérieurement.
• Rendez un membre public lorsqu'il fait partie de l'interface dont les appelants dépendent.
• Rendez-le protected lorsque les sous-classes — mais pas le code extérieur — en ont besoin.
• Rendez-le private lorsqu'il s'agit d'un détail d'implémentation qui pourrait changer sans préavis.
• Préférez les propriétés privées/protégées avec des méthodes getter/setter publiques aux propriétés publiques, afin de garder le contrôle sur la façon dont les valeurs sont lues et écrites. Cette idée fait partie de ce qu'est la POO.

Résumé

Les modificateurs d'accès contrôlent la visibilité des membres d'une classe : public permet l'accès de partout, protected depuis la classe et ses sous-classes, et private uniquement depuis la classe déclarante. Ils s'appliquent aux propriétés, méthodes et constantes, et sont la façon dont PHP applique l'encapsulation. Bien utilisés — en cachant les détails derrière une petite surface publique — ils rendent votre code plus sûr à modifier et plus facile à comprendre.

Pratique