private

La parola chiave private in PHP

private è un modificatore di visibilità (detto anche modificatore di accesso). Quando si contrassegna una proprietà o un metodo come private, questo può essere letto e chiamato solo dall'interno della stessa classe — mai dall'esterno dell'oggetto, e mai da una classe figlia che la estende.

La visibilità è il cuore dell'incapsulamento: consente a una classe di nascondere i propri dati interni e la logica di supporto dietro una superficie pubblica controllata, in modo che il mondo esterno dipenda solo da ciò che si sceglie di esporre. PHP ha tre livelli di visibilità:

Questa pagina illustra la sintassi di private, perché e quando utilizzarlo, e le insidie più comuni — l'ereditarietà, la regola "stessa classe, oggetto diverso" e il comportamento in caso di errore. Per un quadro più ampio, consulta PHP Access Modifiers e PHP Classes and Objects.

Sintassi

Aggiungi la parola chiave private come prefisso alla dichiarazione della proprietà o del metodo:

class MyClass {
  private $myPrivateVariable;

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

Un membro private è completamente utilizzabile all'interno della classe — gli altri metodi di MyClass possono leggere $this->myPrivateVariable e chiamare $this->myPrivateFunction() — ma qualsiasi accesso dall'esterno genera un Error.

Esempi

Vediamo alcuni esempi pratici di come la parola chiave "private" può essere utilizzata:

Esempi di PHP private

<?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!

In entrambi gli esempi, $name, getName() e $balance fanno parte del meccanismo interno della classe. Il mondo esterno interagisce solo con greet(), deposit() e withdraw() — i punti di ingresso sicuri e validati. Questo è l'incapsulamento in azione: il saldo di BankAccount non può mai diventare negativo perché nulla all'esterno della classe può scrivervi direttamente.

Cosa succede quando si viola la regola

Accedere a un membro privato dall'esterno della classe è un Error fatale, non un silenzioso null:

<?php

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

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

Questo è intenzionale — il problema emerge immediatamente invece di lasciare che il codice dipenda silenziosamente dagli interni della classe.

Private è per classe, non per oggetto

Una sorpresa comune: i membri privati sono visibili tra due istanze della stessa classe. Il confine "private" è la classe, quindi un oggetto può leggere i membri privati di un altro oggetto, purché entrambi siano dello stesso tipo:

<?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 ed ereditarietà

A differenza di protected, un membro private non viene ereditato dalle sottoclassi. Una classe figlia non può vedere i membri privati del genitore, e se dichiara un membro con lo stesso nome ottiene la propria copia separata:

<?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() è stato definito in Base, quindi vede il $value privato di Base — il $value della classe figlia è una proprietà completamente separata. Se si desidera che le sottoclassi condividano e sovrascrivano un membro, usa protected. Consulta PHP Inheritance per ulteriori dettagli.

Quando usare private

• Stato interno che deve rimanere valido — come il saldo di BankAccount sopra. Esponi metodi mutatori (deposit, withdraw) che applicano le regole.
• Metodi di supporto che sono dettagli implementativi, così potrai rinominarli o riscriverli in seguito senza rompere i chiamanti.
• Inizia dal livello più restrittivo. Comincia con private; allarga a protected o public solo quando emerge una reale necessità. È molto più semplice allentare la visibilità che restringerla dopo che altro codice vi dipende.

Vantaggi

• Incapsulamento — raggruppa i dati con i metodi che li gestiscono e impedisce al resto del programma di accedervi direttamente. Consulta PHP Classes and Objects.
• Information hiding — i chiamanti dipendono dalla tua API pubblica, non dagli interni, quindi puoi cambiare il funzionamento interno della classe senza romperli.
• Invarianti — poiché le scritture passano attraverso i tuoi metodi, puoi garantire che l'oggetto sia sempre in uno stato valido.

Riepilogo

La parola chiave private limita un membro di classe alla classe che lo dichiara — non alle sue sottoclassi e non al mondo esterno. È lo strumento predefinito per l'incapsulamento: nascondi dati interni e metodi di supporto, esponi una piccola API pubblica validata e mantieni gli oggetti in uno stato coerente. Usa protected quando le sottoclassi necessitano di accesso, e public solo per l'interfaccia prevista.

Esercitazione