private

La palabra clave private en PHP

private es un modificador de visibilidad (también llamado modificador de acceso). Cuando marcas una propiedad o método como private, solo puede ser leído y llamado desde dentro de la misma clase — nunca desde fuera del objeto, y nunca desde una clase hija que la extienda.

La visibilidad es el núcleo de la encapsulación: permite que una clase oculte sus datos internos y la lógica auxiliar detrás de una superficie pública controlada, de modo que el mundo exterior solo dependa de lo que eliges exponer. PHP tiene tres niveles de visibilidad:

Esta página cubre la sintaxis de private, por qué y cuándo usarlo, y los errores comunes que confunden a los desarrolladores — herencia, la regla de "misma clase, diferente objeto" y el comportamiento ante errores. Para una visión más amplia, consulta Modificadores de acceso en PHP y Clases y objetos en PHP.

Sintaxis

Agrega el prefijo private a la declaración de la propiedad o método:

class MyClass {
  private $myPrivateVariable;

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

Un miembro private es completamente utilizable dentro de la clase — otros métodos de MyClass pueden leer $this->myPrivateVariable y llamar a $this->myPrivateFunction() — pero cualquier acceso desde fuera lanza un Error.

Ejemplos

Veamos algunos ejemplos prácticos de cómo se puede usar la palabra clave "private":

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

En ambos ejemplos, $name, getName() y $balance forman parte de la maquinaria interna de la clase. El mundo exterior solo interactúa con greet(), deposit() y withdraw() — los puntos de entrada seguros y validados. Eso es la encapsulación en acción: el saldo de BankAccount nunca puede ser negativo porque nada fuera de la clase puede escribir en él directamente.

Qué ocurre cuando se rompe la regla

Acceder a un miembro privado desde fuera de la clase produce un Error fatal, no un null silencioso:

<?php

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

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

Esto es intencional — expone el error de inmediato en lugar de permitir que el código dependa silenciosamente de los internos.

Private es por clase, no por objeto

Una sorpresa común: los miembros privados son visibles entre dos instancias de la misma clase. El límite de "private" es la clase, de modo que un objeto puede leer los miembros privados de otro objeto siempre que ambos sean del mismo 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 y la herencia

A diferencia de protected, un miembro private no es heredado por las subclases. Una clase hija no puede ver los miembros privados del padre, y si declara un miembro con el mismo nombre obtiene su propia copia independiente:

<?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() fue definido en Base, por lo que ve la $value privada propia de Base — la $value del hijo es una propiedad completamente separada. Si quieres que las subclases compartan y sobreescriban un miembro, usa protected en su lugar. Consulta Herencia en PHP para más información.

Cuándo usar private

• Estado interno que debe mantenerse válido — como el saldo de BankAccount arriba. Expone mutadores (deposit, withdraw) que hacen cumplir las reglas.
• Métodos auxiliares que son detalles de implementación, para que puedas renombrarlos o reescribirlos más tarde sin romper a los llamadores.
• Empieza con el nivel más restrictivo. Comienza con private; amplía a protected o public solo cuando surja una necesidad real. Es mucho más fácil flexibilizar la visibilidad que restringirla cuando otro código ya depende de ella.

Ventajas

• Encapsulación — agrupa los datos con los métodos que operan sobre ellos y evita que el resto del programa los modifique directamente. Consulta Clases y objetos en PHP.
• Ocultamiento de información — los llamadores dependen de tu API pública, no de tus internos, por lo que puedes cambiar el funcionamiento de la clase sin romperlos.
• Invariantes — dado que las escrituras pasan por tus métodos, puedes garantizar que el objeto siempre se encuentre en un estado válido.

Resumen

La palabra clave private restringe un miembro de clase a la clase que lo declara — no a sus subclases ni al mundo exterior. Es la herramienta predeterminada para la encapsulación: oculta datos internos y métodos auxiliares, expone una pequeña API pública validada y mantiene tus objetos en un estado consistente. Usa protected cuando las subclases necesiten acceso, y public solo para la interfaz prevista.

Práctica