private

Le mot-clé private en PHP

private est un modificateur de visibilité (aussi appelé modificateur d'accès). Lorsque vous marquez une propriété ou une méthode private, elle ne peut être lue et appelée que depuis l'intérieur de la même classe — jamais depuis l'extérieur de l'objet, et jamais depuis une classe enfant qui l'étend.

La visibilité est au cœur de l'encapsulation : elle permet à une classe de masquer ses données internes et sa logique utilitaire derrière une interface publique contrôlée, de sorte que le monde extérieur ne dépend que de ce que vous choisissez d'exposer. PHP dispose de trois niveaux de visibilité :

Cette page couvre la syntaxe de private, pourquoi et quand l'utiliser, et les pièges courants — l'héritage, la règle « même classe, objet différent », et le comportement en cas d'erreur. Pour une vue d'ensemble, voir Modificateurs d'accès PHP et Classes et objets PHP.

Syntaxe

Préfixez la déclaration de propriété ou de méthode avec le mot-clé private :

class MyClass {
  private $myPrivateVariable;

  private function myPrivateFunction() {
    // Only code inside MyClass can call this.
  }
}

Un membre private est pleinement utilisable à l'intérieur de la classe — les autres méthodes de MyClass peuvent lire $this->myPrivateVariable et appeler $this->myPrivateFunction() — mais tout accès depuis l'extérieur génère une Error.

Exemples

Voici quelques exemples pratiques d'utilisation du mot-clé "private" :

Exemples de private en PHP

<?php

// Example 1
class Person
{
  private $name;

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

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

  public function greet()
  {
    $name = $this->getName();
    echo "Hello, $name!" . PHP_EOL;
  }
}

$person = new Person("John");
$person->greet(); // Output: Hello, John!

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

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

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

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

Dans les deux exemples, $name, getName() et $balance font partie du mécanisme interne de la classe. Le monde extérieur n'interagit qu'avec greet(), deposit() et withdraw() — les points d'entrée sûrs et validés. C'est l'encapsulation en action : le solde de BankAccount ne peut jamais devenir négatif car rien en dehors de la classe ne peut y écrire directement.

Ce qui se passe quand on enfreint la règle

Accéder à un membre privé depuis l'extérieur de la classe provoque une Error fatale, pas un null silencieux :

<?php

class Person
{
  private $name = "John";
}

$p = new Person();
echo $p->name;
// PHP Fatal error: Uncaught Error: Cannot access private property Person::$name

C'est intentionnel — cela révèle l'erreur immédiatement plutôt que de laisser le code dépendre silencieusement d'éléments internes.

Private est par classe, pas par objet

Une surprise fréquente : les membres privés sont visibles entre deux instances de la même classe. La frontière "private" est la classe, donc un objet peut lire les membres privés d'un autre objet tant que les deux sont du même type :

<?php

class Money
{
  private $cents;

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

  // Reads $other->cents directly — allowed, same class.
  public function add(Money $other)
  {
    return new Money($this->cents + $other->cents);
  }

  public function format()
  {
    return number_format($this->cents / 100, 2);
  }
}

$total = (new Money(150))->add(new Money(350));
echo $total->format(); // Output: 5.00

Private et héritage

Contrairement à protected, un membre private n'est pas hérité par les sous-classes. Une classe enfant ne peut pas voir les membres privés du parent, et si elle déclare un membre du même nom, elle obtient sa propre copie distincte :

<?php

class Base
{
  private $value = "base";

  public function show()
  {
    echo $this->value . PHP_EOL;
  }
}

class Child extends Base
{
  private $value = "child";
}

(new Child())->show(); // Output: base

show() a été défini dans Base, donc il voit le $value privé de Base — le $value de l'enfant est une propriété complètement séparée. Si vous souhaitez que les sous-classes partagent et remplacent un membre, utilisez protected à la place. Voir Héritage PHP pour en savoir plus.

Quand utiliser private

• État interne devant rester valide — comme le solde de BankAccount ci-dessus. Exposez des mutateurs (deposit, withdraw) qui appliquent les règles.
• Méthodes utilitaires qui sont des détails d'implémentation, afin de pouvoir les renommer ou les réécrire ultérieurement sans casser les appelants.
• Commencez avec le niveau le plus restrictif. Débutez avec private ; élargissez à protected ou public uniquement lorsqu'un besoin réel se manifeste. Il est beaucoup plus facile d'assouplir la visibilité que de la restreindre après que d'autres codes en dépendent.

Avantages

• Encapsulation — regroupez les données avec les méthodes qui les manipulent et empêchez le reste du programme d'y accéder directement. Voir Classes et objets PHP.
• Dissimulation d'informations — les appelants dépendent de votre API publique, pas de vos éléments internes, ce qui vous permet de modifier le fonctionnement de la classe sans les casser.
• Invariants — étant donné que les écritures passent par vos méthodes, vous pouvez garantir que l'objet est toujours dans un état valide.

Résumé

Le mot-clé private restreint un membre de classe à la classe qui le déclare — ni ses sous-classes ni le monde extérieur. C'est l'outil par défaut pour l'encapsulation : masquez les données internes et les méthodes utilitaires, exposez une petite API publique validée, et maintenez vos objets dans un état cohérent. Utilisez protected lorsque les sous-classes ont besoin d'accès, et public uniquement pour l'interface prévue.

Pratique