protected

La palabra clave protected de PHP

protected es uno de los tres modificadores de acceso de PHP (junto con public y private). Controla la visibilidad — quién tiene permitido leer o llamar a un miembro de clase.

Un miembro declarado como protected puede ser accedido:

• dentro de la clase que lo declara, y
• dentro de cualquier clase que herede de ella (una subclase).

No puede ser accedido desde "fuera" — es decir, desde código regular que simplemente tiene un objeto ($obj->member). Este punto intermedio es exactamente lo que hace útil a protected: oculta los detalles de implementación del mundo exterior mientras permite que las subclases construyan sobre ellos. Para la comparación completa, consulta Modificadores de acceso en PHP.

Esta página cubre la sintaxis, cómo se comporta protected a través de la herencia, los errores comunes y cuándo usarlo en lugar de private o public.

Sintaxis

Coloca la palabra clave protected delante de la declaración de una propiedad o método:

class MyClass {
  protected $myProtectedProperty;

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

También puedes marcar un miembro estático como protected:

class Config {
  protected static $instances = 0;

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

protected vs private vs public

Los tres modificadores difieren solo en dónde un miembro es visible:

La distinción clave: los miembros private son invisibles incluso para las subclases, mientras que los miembros protected se comparten a lo largo de la cadena de herencia. Elige protected cuando una subclase necesita legítimamente los datos o el método auxiliar, pero aún quieres mantenerlos fuera de la API pública.

Ejemplos

Los ejemplos a continuación muestran miembros protected siendo usados por una subclase (permitido) — luego veremos qué sucede cuando el código externo intenta lo mismo.

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

En ambas clases, la subclase (Dog, SavingsAccount) llama libremente al miembro protected de su padre. Los datos y la lógica auxiliar permanecen reutilizables a través de la herencia sin quedar nunca expuestos al código externo.

El acceso a miembros protected desde fuera falla

En el momento en que intentas acceder a un miembro protected desde código regular, PHP lanza un error fatal:

<?php

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

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

Esta es la protección en acción — la propiedad simplemente no forma parte de la superficie pública del objeto.

Advertencia: una subclase puede acceder a objetos del mismo tipo

Una sorpresa común es que la visibilidad se comprueba por clase, no por objeto individual. Un objeto puede acceder a los miembros protected de otro objeto siempre que ambos sean instancias de la misma clase (o de una clase relacionada que pueda ver el miembro):

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

Cuándo usar protected

Recurre a protected cuando:

• Una subclase necesita reutilizar o sobreescribir estado interno o métodos auxiliares, pero el código externo no debería hacerlo.
• Estás diseñando una clase base destinada a ser extendida (consulta Clases abstractas en PHP), y quieres ofrecer métodos de "bloque constructivo" solo a las subclases.

Prefiere private cuando incluso las subclases no deberían depender de un detalle interno — eso te da la libertad de cambiarlo más adelante sin romper las clases hijas. Prefiere public solo para la API intencional y documentada de la clase.

Resumen

• Los miembros protected son visibles dentro de la clase que los declara y sus subclases, pero no para el código externo.
• Es el punto intermedio entre public (visible en todas partes) y private (visible solo en la clase que lo declara).
• La visibilidad se aplica por clase, por lo que objetos del mismo tipo pueden ver los miembros protected del otro.
• Úsalo para compartir elementos internos reutilizables a lo largo de una cadena de herencia manteniéndolos fuera de la API pública.

Para profundizar más, continúa con Herencia en PHP, Clases y objetos en PHP y Propiedades estáticas.

Práctica