public

La palabra clave public en PHP

public es uno de los tres modificadores de visibilidad (acceso) de PHP, junto con private y protected. Un miembro de clase declarado public puede ser leído y escrito — o, en el caso de los métodos, llamado — desde cualquier lugar: dentro de la clase, desde una subclase y desde cualquier código que tenga un objeto de la clase.

Esta página cubre la sintaxis, dónde se aplica public, cómo se diferencia de los otros modificadores, las reglas de visibilidad por defecto y los errores prácticos de exponer miembros públicamente. Si las clases son nuevas para ti, comienza con Clases y Objetos en PHP.

Sintaxis

Coloca la palabra clave public antes de la declaración de una propiedad, método o constante:

class MyClass {
  public $myPublicProperty;          // public property
  public const VERSION = '1.0';      // public constant (PHP 7.1+)

  public function myPublicMethod() {
    // accessible from anywhere
  }
}

public puede modificar:

• Propiedades — public $name;
• Métodos — public function greet() { ... }
• Constantes — public const MAX = 10; (PHP 7.1+; las constantes son implícitamente públicas si no se indica ningún modificador)
• Parámetros promovidos en el constructor — public function __construct(public string $name) {} (PHP 8.0+)

Visibilidad por defecto

La visibilidad es opcional en PHP. El valor por defecto depende del tipo de miembro:

• Un método sin modificador es implícitamente public. function honk() y public function honk() significan lo mismo.
• Una propiedad debe usar uno de los modificadores (public, protected o private) o var. Históricamente var $x; era un alias de public $x; y sigue siendo aceptado pero está desaconsejado.
• Una constante de clase sin modificador es implícitamente public.

Escribir public explícitamente es el estilo recomendado — deja clara la intención a cualquiera que lea el código.

Ejemplos

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

Ejemplos de la palabra clave public en PHP

<?php

// Example 1
class Car
{
  public $model;
  public $color;

  public function __construct($model, $color)
  {
    $this->model = $model . PHP_EOL;
    $this->color = $color;
  }

  public function honk()
  {
    return "Beep beep!" . PHP_EOL;
  }
}

$myCar = new Car("Tesla", "red");
echo $myCar->model; // Output: Tesla
echo $myCar->honk(); // Output: Beep beep!

// Example 2
class Math
{
  public static function add($a, $b)
  {
    return $a + $b;
  }

  public static function multiply($a, $b)
  {
    return $a * $b;
  }
}

echo Math::add(5, 10); // Output: 15
echo Math::multiply(5, 10); // Output: 50

Aquí, $model, honk() y los métodos estáticos de Math son todos public, por lo que el código que los llama accede a ellos directamente mediante -> (instancias) o :: (miembros estáticos).

Promoción en el constructor (PHP 8.0+)

Desde PHP 8.0 puedes declarar e inicializar una propiedad pública directamente desde un parámetro del constructor, eliminando el repetitivo código $this->x = $x;:

<?php

class Point
{
  public function __construct(
    public int $x = 0,
    public int $y = 0
  ) {}
}

$p = new Point(3, 4);
echo "$p->x,$p->y" . PHP_EOL; // Output: 3,4

Esto equivale a declarar public int $x; y asignarlo en el cuerpo del constructor. Consulta Constructor de PHP para una explicación completa.

public vs. protected vs. private

PHP tiene tres modificadores de visibilidad. La diferencia está en dónde se puede acceder a un miembro:

El siguiente script muestra los límites en acción:

<?php

class Base
{
  public $open = 'public';
  protected $family = 'protected';
  private $secret = 'private';

  public function reveal()
  {
    // Inside the class, all three are reachable.
    return "$this->open / $this->family / $this->secret" . PHP_EOL;
  }
}

$b = new Base();

echo $b->open . PHP_EOL;  // Output: public  (allowed from outside)
echo $b->reveal();        // Output: public / protected / private

// echo $b->family;       // Fatal error: Cannot access protected property
// echo $b->secret;       // Fatal error: Cannot access private property

Solo $open es accesible directamente desde fuera de la clase. $family y $secret solo pueden leerse a través del método público reveal().

Cuándo usar public

Usa public para las partes de una clase que forman su API — los métodos y datos que quieres que otro código use. Mantén todo lo demás como private o protected.

• Expón comportamiento, no estado sin procesar. Prefiere métodos public (getEmail(), withdraw($amount)) sobre propiedades public, para mantener el control sobre la validación y poder cambiar los internos más adelante sin romper a los llamadores.
• Una propiedad public es un contrato: una vez que el código externo depende de ella, renombrarla o eliminarla es un cambio que rompe la compatibilidad.
• Usa public static para métodos de utilidad/fábrica que no necesitan una instancia (consulta Métodos Estáticos de PHP).
• Los métodos de interfaz son siempre efectivamente públicos — consulta Interfaces de PHP.

Resumen

• public hace que un miembro de clase sea accesible desde cualquier lugar; es el más permisivo de los tres modificadores de visibilidad de PHP.
• Los métodos y las constantes son public por defecto; las propiedades deben indicar su visibilidad explícitamente.
• Reserva public para la API prevista de una clase y oculta los detalles de implementación detrás de private/protected para una mejor encapsulación.

Continúa con private, protected y Herencia en PHP para completar tu comprensión de la visibilidad.

Práctica