protected

Le mot-clé PHP protected

protected est l'un des trois modificateurs d'accès de PHP (aux côtés de public et private). Il contrôle la visibilité — qui est autorisé à lire ou appeler un membre d'une classe.

Un membre déclaré protected est accessible :

• à l'intérieur de la classe qui le déclare, et
• à l'intérieur de toute classe qui hérite de celle-ci (une sous-classe).

Il ne peut pas être accédé depuis « l'extérieur » — c'est-à-dire depuis du code ordinaire qui possède simplement un objet ($obj->member). Ce juste milieu est exactement ce qui rend protected utile : il cache les détails d'implémentation du monde extérieur tout en permettant aux sous-classes de s'appuyer dessus. Pour la comparaison complète, consultez les modificateurs d'accès PHP.

Cette page couvre la syntaxe, le comportement de protected à travers l'héritage, les pièges courants, et quand l'utiliser plutôt que private ou public.

Syntaxe

Placez le mot-clé protected devant une déclaration de propriété ou de méthode :

class MyClass {
  protected $myProtectedProperty;

  protected function myProtectedMethod() {
    // Code here
  }
}

Vous pouvez également marquer un membre statique comme protégé :

class Config {
  protected static $instances = 0;

  protected static function register() {
    self::$instances++;
  }
}

protected vs private vs public

Les trois modificateurs diffèrent uniquement par l'endroit où un membre est visible :

La distinction clé : les membres private sont invisibles même pour les sous-classes, tandis que les membres protected sont partagés le long de la chaîne d'héritage. Choisissez protected lorsqu'une sous-classe a légitimement besoin des données ou d'un helper, mais que vous souhaitez tout de même les garder hors de l'API publique.

Exemples

Les exemples ci-dessous montrent des membres protected utilisés par une sous-classe (autorisé) — puis nous verrons ce qui se passe lorsqu'un code extérieur tente la même chose.

<?php

// Example 1
class Animal
{
  protected $name;

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

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

class Dog extends Animal
{
  public function bark()
  {
    $name = $this->getName();
    echo "$name barks!" . PHP_EOL;
  }
}

$dog = new Dog("Rufus");
$dog->bark(); // Output: Rufus barks!

// Example 2
class BankAccount
{
  protected $balance = 0;

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

  protected function canWithdraw($amount)
  {
    return $amount <= $this->balance;
  }
}

class SavingsAccount extends BankAccount
{
  public function withdraw($amount)
  {
    if ($this->canWithdraw($amount)) {
      $this->balance -= $amount;
      echo "Withdrawal successful!" . PHP_EOL;
    } else {
      echo "Insufficient funds!" . PHP_EOL;
    }
  }
}

$savingsAccount = new SavingsAccount();
$savingsAccount->deposit(100);
$savingsAccount->withdraw(50); // Output: Withdrawal successful!
$savingsAccount->withdraw(100); // Output: Insufficient funds!

Dans les deux classes, la sous-classe (Dog, SavingsAccount) appelle librement le membre protégé de son parent. Les données et la logique helper restent réutilisables via l'héritage sans jamais être exposées au code extérieur.

L'accès aux membres protégés depuis l'extérieur échoue

Dès que vous tentez d'accéder à un membre protégé depuis du code ordinaire, PHP lève une erreur fatale :

<?php

class Animal {
  protected $name = "Rufus";
}

$animal = new Animal();
echo $animal->name; // Fatal error: Cannot access protected property Animal::$name

C'est la protection en action — la propriété ne fait tout simplement pas partie de la surface publique de l'objet.

Piège : une sous-classe peut accéder aux membres d'un objet du même type

Une surprise courante est que la visibilité est vérifiée par classe, et non par objet individuel. Un objet peut accéder aux membres protégés d'un autre objet tant que les deux sont des instances de la même classe (ou d'une classe liée pouvant voir le membre) :

<?php

class Wallet {
  protected $balance = 100;

  public function isRicherThan(Wallet $other): bool
  {
    // $other->balance is protected, but we're inside Wallet, so it's allowed
    return $this->balance > $other->balance;
  }
}

$a = new Wallet();
$b = new Wallet();
var_dump($a->isRicherThan($b)); // bool(false)

Quand utiliser protected

Utilisez protected lorsque :

• Une sous-classe doit réutiliser ou redéfinir un état interne ou des méthodes helper, mais le code extérieur ne le devrait pas.
• Vous concevez une classe de base destinée à être étendue (voir les classes abstraites PHP), et vous souhaitez offrir des méthodes « blocs de construction » uniquement aux sous-classes.

Préférez private lorsque même les sous-classes ne devraient pas dépendre d'un détail interne — cela vous donne la liberté de le modifier ultérieurement sans casser les classes enfants. Préférez public uniquement pour l'API intentionnelle et documentée de la classe.

Résumé

• Les membres protected sont visibles à l'intérieur de la classe déclarante et de ses sous-classes, mais pas pour le code extérieur.
• C'est le juste milieu entre public (visible partout) et private (visible uniquement dans la classe déclarante).
• La visibilité est appliquée par classe, donc les objets du même type peuvent accéder aux membres protégés les uns des autres.
• Utilisez-le pour partager des internals réutilisables le long d'une chaîne d'héritage tout en les gardant hors de l'API publique.

Pour approfondir, poursuivez avec l'héritage PHP, les classes et objets PHP, et les propriétés statiques.

Pratique