Skip to content

5. Las clases

Vocabulario: una clase (palabra clave [class]) es un tipo de PHP. Una variable de este tipo se denomina objeto. Un objeto es una instancia de una clase.

Es en este capítulo donde más se hace evidente la evolución de PHP entre las versiones 7 y 8. PHP 8 introdujo una serie de novedades que hacen que escribir clases sea más conciso y seguro: atributos tipados, promoción de parámetros del constructor, atributos de solo lectura ([readonly]), enumeraciones ([enum]), property hooks y visibilidad asimétrica (PHP 8.4), clonación con modificación (PHP 8.5)... Presentamos estos conceptos a través de los ejemplos, siguiendo la progresión del curso de PHP 7: comenzamos con la clase más básica y avanzamos hasta una clase escrita según las mejores prácticas actuales.

5.1. Estructura de directorios de los scripts

Los scripts de este capítulo se encuentran en la carpeta [scripts-console/classes]:

php8-oct-2026/scripts-console/classes
├── json
│   ├── json-01.php
│   ├── json-02.php
│   ├── json-03.php
│   ├── json-04.php
│   ├── Person.php
│   ├── Person2.php
│   ├── Person3.php
│   └── Person4.php
├── classes-01.php
├── classes-02.php
├── ...
├── classes-26.php
├── Gender.php
├── Person.php
├── Student.php
└── Teacher.php

Como en los capítulos anteriores, un script de consola se ejecuta en un terminal de [VS Code] abierto en la carpeta del script, con el comando [php script-name.php].

5.2. ¿Puede cualquier variable convertirse en un objeto con atributos?

En PHP 7 era posible escribir [$obj1->attr1 = "one";] en una variable inexistente [$obj1]: PHP creaba entonces silenciosamente (con una simple advertencia) un objeto de tipo [stdClass] con el atributo [attr1]. Esto ya no es posible en PHP 8. El script [classes-01.php] es el siguiente:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// en PHP 8, una variable inexistente ya no se convierte mágicamente en objeto
try {
    $obj0->attr1 = "one";
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// un objeto genérico debe crearse explícitamente
$obj1 = new \stdClass();
// un objeto [stdClass] puede recibir atributos creados dinámicamente
$obj1->attr1 = "one";
$obj1->attr2 = 100;
// muestra el objeto
print "object1=[$obj1->attr1,$obj1->attr2]\n";
// modifica el objeto
$obj1->attr2 += 100;
// muestra el objeto
print "object1=[$obj1->attr1,$obj1->attr2]\n";
// copia el valor de object1 (dirección del objeto apuntado) en object2
// las dos variables son entonces diferentes pero apuntan al mismo objeto
$obj2 = $obj1;
// modifica obj2
$obj2->attr2 = 0;
// muestra los dos objetos
print "object1=[$obj1->attr1,$obj1->attr2]\n";
print "object2=[$obj2->attr1,$obj2->attr2]\n";
// cambia el objeto apuntado por obj1
$obj1 = new \stdClass();
print "obj1:\n";
print_r($obj1);
print "obj2:\n";
print_r($obj2);
// asigna la referencia (la dirección) de object2 a object3
// $obj2 y $obj3 son entonces una sola y misma variable
$obj3 = &$obj2;
print "obj2:\n";
print_r($obj2);
print "obj3:\n";
print_r($obj3);
// modifica obj3
$obj3->attr2 = 10;
// muestra los dos objetos
print "object2=[$obj2->attr1,$obj2->attr2]\n";
print "object3=[$obj3->attr1,$obj3->attr2]\n";
// cambia el objeto apuntado por obj2
$obj2 = new \stdClass();
$obj2->attr3 = "two";
$obj2->attr4 = 20;
// muestra los dos objetos $obj2 y $obj3
print "obj2:\n";
print_r($obj2);
print "obj3:\n";
print_r($obj3);

// ¿un objeto es un diccionario?
try {
    print count($obj3) . "\n";
} catch (\TypeError $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// el número de atributos se obtiene con [get_object_vars]
print "number of attributes: " . count(get_object_vars($obj3)) . "\n";
// un objeto se puede recorrer con [foreach]
foreach ($obj3 as $attribute => $value) {
    print "obj3[$attribute]=$value\n";
}
// un arreglo asociativo se puede convertir en un objeto [stdClass] y viceversa
$obj4 = (object) ["name" => "Langevin", "age" => 48];
print "obj4=[$obj4->name,$obj4->age]\n";
print_r((array) $obj4);
// fin
exit;

Resultados:

> php classes-01.php
Error: Attempt to assign property "attr1" on null
object1=[one,100]
object1=[one,200]
object1=[one,0]
object2=[one,0]
obj1:
stdClass Object
(
)
obj2:
stdClass Object
(
    [attr1] => one
    [attr2] => 0
)
obj2:
stdClass Object
(
    [attr1] => one
    [attr2] => 0
)
obj3:
stdClass Object
(
    [attr1] => one
    [attr2] => 0
)
object2=[one,10]
object3=[one,10]
obj2:
stdClass Object
(
    [attr3] => two
    [attr4] => 20
)
obj3:
stdClass Object
(
    [attr3] => two
    [attr4] => 20
)
Error: count(): Argument #1 ($value) must be of type Countable|array, stdClass given
number of attributes: 2
obj3[attr3]=two
obj3[attr4]=20
obj4=[Langevin,48]
Array
(
    [name] => Langevin
    [age] => 48
)

Comentarios

  • líneas 7–9: en PHP 8, la variable [$obj0] no existe y la operación [$obj0->attr1 = "one"] lanza un error de tipo [\Error] (línea 2 de los resultados) en lugar de crear un objeto. Examinaremos la estructura [try / catch] en el capítulo sobre excepciones. Por ahora, basta con saber que permite capturar el error y continuar la ejecución del script;
  • línea 13: un objeto genérico debe crearse explícitamente con el operador [new]. La clase predefinida [stdClass] es una clase vacía;
  • líneas 15–16: la notación [$obj->attr] designa el atributo [attr] del objeto [$obj]. Si no existe, se crea; esto se denomina atributo dinámico. La clase [stdClass] está diseñada para este fin: se le pueden agregar tantos atributos como se desee;
  • línea 25: la expresión [$obj2 = $obj1], cuando [$obj1] es un objeto, es una copia de referencias: [$obj2] y [$obj1] son referencias (direcciones) al mismo objeto. El objeto mismo puede modificarse a través de cualquiera de las referencias;
  • líneas 27–30: tienen por objeto mostrar que [$obj1] y [$obj2] son dos variables diferentes que apuntan al mismo objeto. [$obj2 = $obj1] copió el valor de [$obj1] en la variable [$obj2] (operación 1 a continuación). El valor de [$obj1] es la dirección de un objeto. Así, [$obj1] y [$obj2] apuntan al mismo objeto. Cuando se manipula una variable [$obj] que apunta a un objeto, PHP manipula el objeto apuntado. Como muestra el siguiente diagrama, podemos modificar el objeto referenciado ya sea a través de [$obj1] o a través de [$obj2]. Esto se ilustra en las líneas 5 y 6 de los resultados;

Image

  • línea 39: la expresión [$obj3 = &$obj2] hace que [$obj2] y [$obj3] estén en la misma dirección que [1 below]. Se podría decir que las dos variables son alias de la misma ubicación de memoria. Ambas apuntan a un objeto, el Objeto A a continuación: [2];
  • línea 50: la operación [$obj2 = new \stdClass()] crea un nuevo objeto, el Objeto B [3 below], y la dirección de este nuevo objeto se asigna a la variable [$obj2] [4]. Como [$obj2] y [$obj3] son dos alias de la misma ubicación de memoria, [$obj3] también apunta al nuevo Objeto B. Esto se muestra en las líneas 31–42 de los resultados;

Image

  • línea 61: ¿es un objeto un diccionario? En PHP 7, la función [count] aceptaba un objeto (con una advertencia) y devolvía 1, lo que no tenía sentido. En PHP 8, lanza un error [TypeError]: [count] acepta solo arreglos u objetos que implementen la interfaz [Countable] (línea 43 de los resultados);
  • línea 66: la función [get_object_vars] devuelve los atributos de un objeto como un arreglo asociativo. El número de elementos del arreglo es igual al número de atributos del objeto;
  • líneas 68–69: se puede iterar sobre un objeto con [foreach], igual que sobre un diccionario. Las claves son los nombres de los atributos y los valores son los valores de esos mismos atributos. Así, un objeto comparte similitudes con un diccionario, pero no es uno. En PHP 7, esta iteración se realizaba con la función [each], que desde entonces fue eliminada;
  • líneas 72–74: el operador de conversión [(object)] convierte un arreglo asociativo en un objeto [stdClass], y el operador [(array)] realiza la operación inversa.

5.3. Una clase Person sin atributos declarados

En PHP 7, una clase podía utilizar atributos que no había declarado: bastaba con escribir [$p->firstName = "Paul";] para crear el atributo [firstName] en el objeto [$p], tal como se hace con [stdClass]. Estos atributos dinámicos en objetos de una clase ordinaria están obsoletos desde PHP 8.2: cada vez que se crea un atributo de este tipo, se muestra el mensaje “Deprecated: Creation of dynamic property Person::$firstName is deprecated”. Se eliminarán en una versión futura de PHP. La razón es simple: un error tipográfico en el nombre de un atributo ([$p->firstNam = "Paul"]) crearía silenciosamente un nuevo atributo en lugar de informar el error.

Hay tres excepciones a esta regla:

  • la clase [stdClass], que acabamos de utilizar, sigue aceptando atributos dinámicos;
  • una clase precedida por el atributo [#[\AllowDynamicProperties]] también los acepta. Este atributo fue diseñado para facilitar la migración de código heredado. No lo utilizaremos en este curso;
  • una clase que define los métodos mágicos [__get] y [__set] decide por sí misma qué hacer con un atributo no declarado.

Esta tercera solución es la que presenta el script [classes-02.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // los atributos no se declaran uno por uno:
    // se almacenan en un arreglo privado
    private array $attributes = [];

    // se llama al escribir un atributo no declarado: $p->x = value
    public function __set(string $name, mixed $value): void
    {
        $this->attributes[$name] = $value;
    }

    // se llama al leer un atributo no declarado: $p->x
    public function __get(string $name): mixed
    {
        return $this->attributes[$name] ?? null;
    }

    // lo llama isset($p->x)
    public function __isset(string $name): bool
    {
        return isset($this->attributes[$name]);
    }

    // método
    public function identity(): string
    {
        // usa atributos que no han sido declarados
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

// prueba
// los atributos se crean mediante el método mágico [__set]
$p = new Person();
$p->firstName = "Paul";
$p->lastName = "Langevin";
$p->age = 48;
// llamada a un método
print "person=" . $p->identity() . "\n";
// isset
print "isset(\$p->age): " . var_export(isset($p->age), true) . "\n";
print "isset(\$p->address): " . var_export(isset($p->address), true) . "\n";
// fin
exit;

Resultados:

1
2
3
4
> php classes-02.php
person=[Paul,Langevin,48]
isset($p->age): true
isset($p->address): false

Comentarios

  • líneas 6–38: definen una clase llamada [Person]. Una clase es una plantilla que sirve para crear objetos. Se compone de atributos y de funciones llamadas métodos;
  • línea 10: el único atributo declarado para la clase es un arreglo privado (pronto veremos el significado de la palabra clave [private]). Este arreglo almacenará los atributos “no declarados”;
  • líneas 13–16: PHP llama automáticamente al método mágico [__set] cuando se escribe en un atributo que no existe (o que no es accesible). Recibe el nombre del atributo y el valor que se le va a asignar. Aquí, almacena este valor en el arreglo [$attributes]. Los métodos cuyos nombres comienzan con dos guiones bajos se denominan métodos mágicos: no se llaman explícitamente; es PHP quien los llama;
  • líneas 19–22: el método mágico [__get] se llama al leer un atributo que no existe. Devuelve el valor almacenado o [null]. El operador [??] devuelve su operando izquierdo si existe y no es [null]; en caso contrario, devuelve su operando derecho;
  • línea 25: la función [isset] llama al método mágico [__isset];
  • línea 31: el método [identity] utiliza tres atributos que no están declarados en la clase. La palabra clave [$this] designa el objeto al que se aplica el método. Cada llamada a [$this->firstName] desencadena una llamada a [__get];
  • línea 40: se crea un objeto [$p] de tipo [Person] . La palabra clave [new] se utiliza para crear un nuevo objeto. La operación devuelve una referencia al objeto creado (es decir, una dirección). Son posibles varias notaciones: [new Person()], [new Person], [new person]. El nombre de la clase no distingue entre mayúsculas y minúsculas;
  • líneas 41–43: los tres atributos requeridos por el método [identity] se crean en el objeto [$p] mediante el método [__set];
  • línea 45: el método [identity] de la clase [Person] se aplica al objeto [$p]. En el código del método [identity], [$this] hace referencia al mismo objeto que [$p].

Esta técnica tiene sus usos (objetos de configuración, encapsulación de datos leídos de un archivo), pero no es la forma estándar de escribir una clase. En una clase normal, se declaran sus atributos.

5.4. La clase Person con atributos declarados

El script [classes-03.php] es el siguiente:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // atributos de la clase, públicos y tipados
    public string $firstName;
    public string $lastName;
    public int $age;

    // método
    public function identity(): string
    {
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

// prueba
// los atributos son públicos
$p = new Person();
$p->firstName = "Paul";
$p->lastName = "Langevin";
$p->age = 48;
// llamada a un método
print "person=" . $p->identity() . "\n";
// un atributo tipado solo acepta valores de su tipo
try {
    $p->age = "forty-eight";
} catch (\TypeError $e) {
    print "Error 1: " . $e->getMessage() . "\n";
}
// un atributo tipado no inicializado no puede leerse
$p2 = new Person();
try {
    print "person=" . $p2->identity() . "\n";
} catch (\Error $e) {
    print "Error 2: " . $e->getMessage() . "\n";
}
// fin
exit;

Resultados:

1
2
3
4
> php classes-03.php
person=[Paul,Langevin,48]
Error 1: Cannot assign string to property Person::$age of type int
Error 2: Typed property Person::$firstName must not be accessed before initialization

Comentarios

  • líneas 9–11: los atributos de la clase se declaran explícitamente. La palabra clave [public] significa que son accesibles desde fuera de la clase. En PHP 7, el curso utilizaba la palabra clave [var], heredada de PHP 4, que es sinónimo de [public] y que ya no se utiliza hoy en día;
  • cada atributo va precedido de su tipo: [string] para el nombre y el apellido, [int] para la edad. Son atributos tipados, que se introdujeron con PHP 7.4. Los tipos posibles son los de los parámetros de las funciones: [int], [float], [string], [bool], [array], el nombre de una clase o interfaz, un tipo que admite nulos [?string], un tipo unión [int|float]...;
  • línea 30: un atributo tipado solo acepta valores de su tipo. Cualquier otro valor provoca un error [TypeError] (línea 3 de los resultados);
  • líneas 35–37: un atributo tipado sin valor predeterminado se encuentra en el estado “no inicializado” hasta que se le asigna un valor. Leerlo provoca un error (línea 4 de los resultados). Los atributos sin tipo, en cambio, tienen como valor predeterminado [null]. Esta es una de las razones para inicializar todos los atributos de un objeto en cuanto se crea: ese es el papel del constructor.

5.5. La clase Person con un constructor

Los ejemplos anteriores mostraron clases exóticas, como las que se encontraban en PHP 4. No se recomienda seguir estos ejemplos. Presentamos ahora una clase [Person] [classes-04.php] que sigue las mejores prácticas habituales, como se encuentran en todos los lenguajes orientados a objetos (Java, C#, etc.):

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // atributos de la clase
    private string $firstName;
    private string $lastName;
    private int $age;

    // getters y setters
    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }

    public function getAge(): int
    {
        return $this->age;
    }

    public function setFirstName(string $firstName): void
    {
        $this->firstName = $firstName;
    }

    public function setLastName(string $lastName): void
    {
        $this->lastName = $lastName;
    }

    public function setAge(int $age): void
    {
        $this->age = $age;
    }

    // constructor
    public function __construct(string $firstName, string $lastName, int $age)
    {
        // pasamos por los setters
        $this->setFirstName($firstName);
        $this->setLastName($lastName);
        $this->setAge($age);
    }

    // método toString
    public function __toString(): string
    {
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

// prueba
// creación de un objeto Person
$p = new Person("Paul", "Langevin", 48);
// identidad de esta persona
print "person=$p\n";
// cambiamos la edad
$p->setAge(14);
// identidad de la persona
print "person=$p\n";
// una clase que tiene un método [__toString] implementa la interfaz [Stringable]
print "Stringable: " . var_export($p instanceof \Stringable, true) . "\n";
// un atributo privado no es accesible desde fuera de la clase
try {
    print $p->lastName;
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// fin
exit;

Resultados:

1
2
3
4
5
> php classes-04.php
person=[Paul,Langevin,48]
person=[Paul,Langevin,14]
Stringable: true
Error: Cannot access private property Person::$lastName

Comentarios

  • línea 4: especificamos que deben respetarse estrictamente los tipos declarados de los parámetros de las funciones. Sin esta declaración, PHP intentaría convertir un valor de tipo incorrecto (por ejemplo, la cadena ["48"] en un entero [48]);
  • líneas 6–60: la clase [Person];
  • líneas 9–11: los atributos privados de la clase ([private]). Estos atributos solo son visibles dentro de la clase. Otras palabras clave que se pueden utilizar son:
    • [public]: hace que el atributo sea público y visible desde fuera de la clase;
    • [protected]: hace que el atributo sea protegido y visible desde dentro de la clase y de sus clases derivadas;
  • Como los atributos son privados, no se puede acceder a ellos desde fuera de la clase. Por lo tanto, no podemos escribir [$p->lastName = "Landru"]: estamos fuera de la clase [Person], y el atributo [lastName] es privado. Las líneas 72–74 lo verifican: intentar leer [$p->lastName] produce un error (línea 5 de los resultados). Para inicializar los atributos privados del objeto [$p], hay dos maneras:
    • utilizar los métodos públicos [set] y [get] (los nombres de estos métodos pueden ser cualesquiera) en las líneas 14–39. En este caso, se escribe: [$p->setLastName("Landru")];
    • utilizar el constructor en las líneas 45–50. Entonces se escribiría: [$p = new Person("Michel", "Landru", 44)]. Esta sintaxis llama automáticamente al método de la clase [Person] denominado [__construct];
  • línea 64: esta línea muestra a la persona [$p] como una cadena. Para ello se utiliza el método de la clase [Person] llamado [__toString] (línea 54);
  • línea 70: a partir de PHP 8.0, toda clase que define un método llamado [__toString] implementa automáticamente la interfaz predefinida [Stringable] (veremos las interfaces en el próximo capítulo). El operador [instanceof] verifica si un objeto es de un tipo determinado. Así, una función puede declarar un parámetro de tipo [string|Stringable]: acepta entonces una cadena o cualquier objeto que se pueda convertir en cadena;
  • todos los métodos de la clase se han precedido de la palabra clave [public], que indica que el método es visible fuera de la clase. Las otras palabras clave que se pueden utilizar son, como con los atributos y con el mismo significado, [private] y [protected]. Sin una palabra clave de visibilidad explícita, el método es implícitamente [public]. Las guías de estilo PSR-12, que siguen los scripts de este curso, exigen que la visibilidad se especifique siempre de forma explícita.

5.6. Promoción de parámetros del constructor

La clase anterior es prolija: cada atributo se nombra cuatro veces (declaración, parámetro del constructor, asignación en el constructor, getter). Desde PHP 8.0, la promoción de parámetros del constructor permite declarar e inicializar un atributo directamente en la lista de parámetros del constructor. El script [classes-22.php] lo demuestra:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // constructor con promoción de parámetros:
    // cada parámetro precedido de una visibilidad se convierte en un atributo de la clase
    public function __construct(
        private string $firstName,
        private string $lastName,
        private int $age = 0,
    ) {
        // nada más que hacer: los atributos ya están inicializados
    }

    // getters
    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }

    public function getAge(): int
    {
        return $this->age;
    }

    // setter
    public function setAge(int $age): void
    {
        $this->age = $age;
    }

    // método toString
    public function __toString(): string
    {
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

// prueba
// llamada clásica: los argumentos se pasan en el orden de los parámetros
$p1 = new Person("Paul", "Langevin", 48);
print "p1=$p1\n";
// argumentos con nombre: el orden ya no importa
$p2 = new Person(lastName: "Lefur", age: 70, firstName: "Sylvie");
print "p2=$p2\n";
// el parámetro [age] tiene un valor por defecto: puede omitirse
$p3 = new Person(firstName: "Steve", lastName: "Boer");
print "p3=$p3\n";
// los atributos promovidos son atributos reales
var_dump($p3);
// fin
exit;

Resultados:

> php classes-22.php
p1=[Paul,Langevin,48]
p2=[Sylvie,Lefur,70]
p3=[Steve,Boer,0]
object(Person)#3 (3) {
  ["firstName":"Person":private]=>
  string(5) "Steve"
  ["lastName":"Person":private]=>
  string(4) "Boer"
  ["age":"Person":private]=>
  int(0)
}

Comentarios

  • líneas 10–14: cada parámetro del constructor precedido de una palabra clave de visibilidad ([private], [protected], [public]) se “promueve”: PHP declara un atributo con el mismo nombre y tipo y le asigna el valor del parámetro. Estas tres líneas reemplazan las declaraciones y asignaciones de atributos de la clase anterior;
  • línea 13: un parámetro promovido puede tener un valor predeterminado. La coma después del último parámetro está permitida desde PHP 8.0; facilita agregar un parámetro más adelante;
  • línea 15: el cuerpo del constructor puede contener código (por ejemplo, validaciones). Aquí no hay nada que hacer;
  • línea 52: los argumentos con nombre (PHP 8.0) permiten pasar los argumentos en cualquier orden refiriéndose a ellos por el nombre del parámetro. Esto hace que el código sea más legible, sobre todo cuando una función tiene muchos parámetros;
  • línea 55: se omite el parámetro [age] ; toma su valor predeterminado;
  • línea 58: la función [var_dump] muestra que los atributos promovidos son verdaderos atributos privados de la clase (líneas 5–12 de los resultados).

5.7. La clase Person con verificaciones de validez en el constructor

El constructor de una clase es el lugar adecuado para verificar que los valores de inicialización del objeto sean correctos. Sin embargo, un objeto también puede inicializarse mediante sus métodos [set] o equivalentes. Para evitar duplicar las mismas verificaciones en dos lugares diferentes, estas verificaciones se pueden colocar en los métodos [set]. Si un valor de inicialización del objeto resulta incorrecto, se lanzará una excepción. Veamos un ejemplo.

Primero, trasladamos la definición de la clase [Person] a su propio archivo, [Person.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// clase Person
class Person
{
    // atributos de la clase
    private string $firstName;
    private string $lastName;
    private int $age;

    // getters y setters
    public function getFirstName(): string
    {
        return $this->firstName;
    }

    public function getLastName(): string
    {
        return $this->lastName;
    }

    public function getAge(): int
    {
        return $this->age;
    }

    public function setFirstName(string $firstName): void
    {
        // el nombre no debe estar vacío
        $firstName = trim($firstName);
        if ($firstName === "") {
            throw new \Exception("The first name must not be empty");
        }
        $this->firstName = $firstName;
    }

    public function setLastName(string $lastName): void
    {
        // el apellido no debe estar vacío
        $lastName = trim($lastName);
        if ($lastName === "") {
            throw new \Exception("The last name must not be empty");
        }
        $this->lastName = $lastName;
    }

    public function setAge(int $age): void
    {
        // la edad debe ser válida
        if ($age < 0) {
            throw new \Exception("The age must be a positive or zero integer");
        }
        $this->age = $age;
    }

    // constructor
    public function __construct(string $firstName, string $lastName, int $age)
    {
        // pasamos por los setters
        $this->setFirstName($firstName);
        $this->setLastName($lastName);
        $this->setAge($age);
    }

    // método que actúa como segundo constructor
    public function initWithPerson(Person $p): void
    {
        // inicializa el objeto actual con una persona $p
        $this->__construct($p->firstName, $p->lastName, $p->age);
    }

    // método de fábrica estático (constructor con nombre)
    public static function fromPerson(Person $p): self
    {
        // crea una nueva persona, copia de la persona $p
        return new self($p->firstName, $p->lastName, $p->age);
    }

    // método toString
    public function __toString(): string
    {
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

Comentarios

  • línea 4: especifica que se deben respetar los tipos de los parámetros de las funciones tal como se declaran;
  • línea 7: define un espacio de nombres (namespace). El nombre completo (o calificado) de la clase [Person] es, por lo tanto, [\Examples\Person]. Observe el carácter [\] al comienzo del nombre calificado: esto produce un nombre calificado absoluto. Si este carácter no está presente, el nombre es un nombre calificado relativo (relativo al espacio de nombres actual). Así, si dos clases, A y B, pertenecen al mismo espacio de nombres E, en el código de la clase A se puede acceder a la clase B mediante la notación relativa B. Si la clase A forma parte del espacio de nombres E1 y la clase B forma parte del espacio de nombres E2, entonces en el código de la clase A se puede acceder a la clase B mediante la notación absoluta [\E2\B]. Definir una clase dentro de un espacio de nombres no es obligatorio, pero se considera una buena práctica: dos bibliotecas pueden entonces definir cada una una clase llamada [Person] sin conflicto;
  • los espacios de nombres suelen corresponder a la estructura de directorios de los archivos. Así, la clase A del espacio de nombres E1 suele estar ubicada en un archivo llamado [E1/A.php]. Esta es la convención PSR-4 que utiliza la herramienta [Composer] para cargar clases automáticamente, y que usaremos en capítulos posteriores. La extensión [PHP Intelephense] de [VS Code] no lo exige. No confunda el árbol de archivos con un espacio de nombres: el nombre completo de una clase utiliza un espacio de nombres y no tiene nada que ver con el árbol de archivos del archivo PHP que contiene la clase. Aquí, la clase [\Examples\Person] está en el archivo [scripts-console/classes/Person.php];
  • líneas 13–15: los tres atributos privados de la clase;
  • líneas 33–41: inicialización del atributo [firstName] y verificación del valor de inicialización;
  • línea 36: la función [trim($string)] elimina los espacios al principio y al final de [$string]. Así, [trim(" abcd ")] es la cadena ["abcd"], y [trim(" ")] es la cadena vacía.;
  • línea 37: si el nombre está vacío, se lanza una excepción (línea 38); de lo contrario, se almacena el nombre (línea 40). Para lanzar una excepción se utiliza aquí la clase predefinida [Exception]. En este caso, estamos obligados a usar su nombre absoluto, [\Exception]. Si usáramos su nombre relativo, [Exception], esta clase se buscaría en el espacio de nombres actual, es decir, en el espacio de nombres [Examples] de la clase [Person]. Así, el intérprete de PHP buscaría una clase con el nombre absoluto [\Examples\Exception], que no existe;
  • líneas 63–69: el constructor utiliza los métodos [set] para inicializar los atributos: las validaciones se escriben una sola vez;
  • Los métodos de las líneas 72 y 79 se describen en el párrafo siguiente.

La clase [Person] es utilizada por el siguiente script, [classes-05.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión de la definición de la clase Person
require_once __DIR__ . "/Person.php";
// para demostración
print __DIR__ . "/Person.php\n";

// nombre calificado de la clase Person
use Examples\Person;

// prueba
// creación de un objeto Person
$p = new Person("Paul", "Langevin", 48);
// identidad de esta persona
print "Example1, person=$p\n";
// creación de un objeto Person inválido
try {
    $p = new Person("xx", "yy", "zz");
} catch (\Exception $e1) {
    print "Example2, error: " . $e1->getMessage() . "\n";
} catch (\TypeError $e2) {
    print "Example2, error: " . $e2->getMessage() . "\n";
}
// creación de un objeto Person inválido
try {
    $p = new Person("", "yy", 10);
} catch (\Exception $e1) {
    print "Example3, error: " . $e1->getMessage() . "\n";
} catch (\TypeError $e2) {
    print "Example3, error: " . $e2->getMessage() . "\n";
}

// fin
exit;

Resultados:

1
2
3
4
5
> php classes-05.php
.../php8-oct-2026/scripts-console/classes/Person.php
Example1, person=[Paul,Langevin,48]
Example2, error: Examples\Person::__construct(): Argument #3 ($age) must be of type int, string given, called in .../php8-oct-2026/scripts-console/classes/classes-05.php on line 21
Example3, error: The first name must not be empty

Comentarios

  • Línea 7: el script utilizará la clase [Person]. Por lo tanto, hay que indicar al intérprete de PHP dónde encontrar la definición de esta clase. Esta es la finalidad de las instrucciones [include file] y [require file] . La diferencia entre ambas es la siguiente: si la instrucción [include file] encuentra errores al cargar [file], se emite un error de nivel [E_WARNING], pero la ejecución continúa, mientras que [require], en la misma situación, genera un error fatal y detiene la ejecución del script. Cada una de estas dos instrucciones tiene una variante: [include_once] y [require_once]. Estas dos variantes permiten manejar los casos en que un mismo archivo se incluye varias veces. Considere, por ejemplo, un proyecto formado por varios scripts PHP, algunos de los cuales hacen referencia a la clase [Person]. La ejecución de estos scripts provocaría que el archivo [Person.php] se incluyera varias veces, lo que produciría un error porque una clase no puede definirse dos veces. La solución es utilizar las variantes [_once], que garantizan que el archivo se incluya una sola vez en el script global del proyecto;
  • La constante [__DIR__] es una constante de PHP que hace referencia al nombre completo de la carpeta que contiene el script donde aparece la constante [__DIR__]. La línea 9 la muestra (línea 2 de los resultados). En la máquina del lector, el resultado será algo como [C:\laragon\www\php8-oct-2026\scripts-console\classes/Person.php]. En una ruta de archivo, en Windows se puede usar indistintamente [/] o [\] . El uso de [__DIR__] hace que el script sea independiente de la carpeta actual en el momento de la ejecución;
  • Línea 12: el script [classes-05.php] no tiene espacio de nombres. Cuando el código utiliza el nombre relativo [Person], este se busca en el espacio de nombres raíz [\] y, por lo tanto, no se encontrará. Hay dos soluciones a este problema:
    • utilizar el nombre completo de la clase [\Examples\Person];
    • utilizar la instrucción [use], que especifica que, en el código que sigue, el nombre [Person] se refiere a la clase [\Examples\Person]. En una instrucción [use], el nombre siempre es absoluto: la [\] inicial es innecesaria (esta es la notación recomendada). La instrucción equivale a [use Examples\Person as Person;], que especifica que el alias [Person] se refiere a la clase [\Examples\Person];
  • la instrucción [use] indica al intérprete que la clase [Person] es en realidad la clase [\Examples\Person]. Dicho esto, ¿dónde encontrará el intérprete el código de esta clase? Se lo indica la instrucción [require_once] . Las dos instrucciones tienen funciones muy distintas: [use] trabaja con nombres, [require_once] carga un archivo;
  • línea 16: se crea un objeto [Person]. Aquí se ejecutará implícitamente el método [__construct] de la clase [Person];
  • línea 18: muestra la persona [$p]. Para poder mostrarse, el valor de la variable [$p] debe convertirse en una cadena. Implícitamente, se ejecuta entonces el método [Person::__toString] . Por lo tanto, este método debe devolver una cadena;
  • hemos visto que el constructor de la clase [Person] puede lanzar una excepción [\Exception]. Por lo tanto, esta excepción debe manejarse. En consecuencia, la creación de una persona siempre debe estar dentro de una estructura ***[try / catch] , como se muestra en las líneas 20–34. Aquí provocamos intencionalmente un error al pasar una edad que no es un entero. En este caso concreto, el error lo lanza el intérprete de PHP y no el código de la clase [Person]. Esto se debe a que la firma del método [Person::__construct]* es [__construct(string $firstName, string $lastName, int $age)]. Por lo tanto, el parámetro [age] que se pasa al constructor debe ser de tipo entero. Si no lo es, el intérprete de PHP lanza un error de tipo [TypeError]. Además, los métodos [set] de la clase [Person]* lanzan una excepción de tipo [\Exception]. Como el constructor que los llama no tiene una estructura [try / catch], la excepción se propaga un nivel hacia arriba, hasta el código que llamó al constructor, es decir, el código del script [classes-05.php]. Por último, el script [classes-05.php]* puede recibir dos tipos de errores: [\Exception] o [\TypeError]. Por eso, la estructura [try] tiene dos cláusulas [catch] para manejar los dos tipos de errores por separado. Cuando el desarrollador tiene la certeza de que ciertos errores no pueden ocurrir, no utilizará las cláusulas [catch]** correspondientes. Aquí se usan sistemáticamente solo con fines de demostración;
  • Línea 22: se puede escribir [Exception] o [\Exception]. La primera versión utiliza el nombre de clase relativo, relativo al espacio de nombres del script. Como el script no tiene espacio de nombres, su espacio de nombres es la raíz de los espacios de nombres: [\]. Por lo tanto, escribir aquí [Exception] equivale a escribir [\Exception]. Es preferible usar los nombres absolutos de las clases predefinidas de PHP en un script que no tiene un espacio de nombres propio. Así, si se decide asignar un espacio de nombres a este script, el uso de nombres de clase absolutos sigue siendo válido, mientras que, en el otro caso, cambiar el espacio de nombres provocará errores con los nombres de clase relativos;
  • Línea 23: cuando se produce una excepción, el método [Exception::getMessage] obtiene el mensaje de error de la excepción. Lo mismo ocurre con un error de tipo [TypeError]. En el método [Person::setFirstName] se escribió [throw new \Exception("The first name must not be empty")]. Este es el mensaje que obtiene el método [getMessage] en el ejemplo 3 (línea 5 de los resultados);
  • línea 4 de los resultados: el mensaje de error de [TypeError]. A partir de PHP 8.0, identifica el parámetro problemático por su número y nombre: “Argument #3 ($age) must be of type int, string given.” Los mensajes de error de PHP 8 son más específicos que los de PHP 7.

5.8. Agregar un método que actúe como segundo constructor

En PHP no es posible tener varios constructores con parámetros diferentes que permitan construir un objeto de distintas maneras. Por lo tanto, se pueden usar métodos que actúen como constructores. La clase [Person] tiene dos métodos de este tipo:

    public function initWithPerson(Person $p): void
    {
        // inicializa el objeto actual con una persona $p
        $this->__construct($p->firstName, $p->lastName, $p->age);
    }

    // método de fábrica estático (constructor con nombre)
    public static function fromPerson(Person $p): self
    {
        // crea una nueva persona, copia de la persona $p
        return new self($p->firstName, $p->lastName, $p->age);
    }

Comentarios

  • Líneas 72–76: el método [initWithPerson] permite asignar al objeto actual los valores de los atributos de otro objeto [Person]. Aquí llama al constructor [__construct], pero esto no es obligatorio. Podría inicializar por sí mismo los atributos de la clase [Person]. Observe que un método de la clase [Person] tiene acceso a los atributos privados de todos los objetos [Person], no solo a los de [$this];
  • líneas 79–83: el método [fromPerson] es otra forma de hacerlo, más común hoy en día. Es un método estático (palabra clave [static]): no se aplica a un objeto sino a la clase. Se llama mediante la notación [Person::fromPerson($p)]. Crea un nuevo objeto mediante [new self(...)]: la palabra clave [self] se refiere a la clase en la que está escrito el código, en este caso [Person]. El tipo de retorno [self] indica que el método devuelve un objeto de esta clase. Un método de este tipo se denomina constructor con nombre o método de fábrica. Volveremos a los métodos estáticos un poco más adelante.

La nueva clase [Person] es utilizada por el siguiente script, [classes-06.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión de la definición de la clase Person
require_once __DIR__ . "/Person.php";
// declaración del nombre calificado de la clase Person
use Examples\Person;

// prueba
// creación de un objeto Person
try {
    $p = new Person("Paul", "Langevin", 48);
} catch (\Exception $e) {
    print "error: " . $e->getMessage() . "\n";
    exit;
}
// identidad de esta persona
print "person=$p\n";
// creación de una segunda persona
try {
    $p2 = new Person("Laure", "Adeline", 67);
} catch (\Exception $e) {
    print "error: " . $e->getMessage() . "\n";
    exit;
}
// inicialización de la primera con los valores de la segunda
try {
    $p->initWithPerson($p2);
} catch (\Exception $e) {
    print "error: " . $e->getMessage() . "\n";
    exit;
}
// verificación
print "person=$p\n";

// creación de una tercera persona con el constructor con nombre
$p3 = Person::fromPerson($p2);
print "person=$p3\n";
// $p3 y $p2 son dos objetos diferentes con los mismos valores
print "same object: " . var_export($p3 === $p2, true) . "\n";
print "same values: " . var_export($p3 == $p2, true) . "\n";
// fin
exit;

Resultados:

1
2
3
4
5
6
> php classes-06.php
person=[Paul,Langevin,48]
person=[Laure,Adeline,67]
person=[Laure,Adeline,67]
same object: false
same values: true

Comentarios

  • Línea 17, línea 26, línea 33: es común que, después de una excepción, se deba detener la ejecución de un script de consola si el error encontrado es irrecuperable. No ocurre así en un script web: no se detiene la ejecución del script, sino que se muestra una página de error. Si se está dentro de una función, no se usará la instrucción [exit]; en su lugar, se usará [return]: no se detiene la ejecución del script ([exit]), sino que se sale de la función ([return]) después de haber registrado un error;
  • línea 39: llamada al constructor con nombre;
  • línea 42: el operador [===] aplicado a dos objetos se evalúa como verdadero si son el mismo objeto (misma dirección). [$p3] y [$p2] son dos objetos distintos (línea 5 de los resultados);
  • línea 43: el operador [==], aplicado a dos objetos de la misma clase, se evalúa como verdadero si sus atributos tienen los mismos valores (línea 6 de los resultados). La función [var_export] devuelve una representación PHP de su parámetro, en este caso [true] o [false].

5.9. Comprobaciones de validez mediante property hooks (PHP 8.4)

La clase anterior, [Person], protege sus atributos haciéndolos privados y obligando al código externo a utilizar los métodos [get] y [set] . PHP 8.4 ofrece otra solución: los property hooks. Un atributo público puede ir acompañado de un hook [set] (el código que se ejecuta cada vez que se escribe el atributo) y de un hook [get] (el código que se ejecuta cada vez que se lee el atributo). Esto conserva la simplicidad de escribir [$p->age = 49] y, al mismo tiempo, mantiene el control sobre los valores. Lo demuestra el script [classes-23.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // atributo público con un hook [set]: la validación se hace en cada escritura
    public string $firstName {
        set(string $value) {
            $value = trim($value);
            if ($value === "") {
                throw new \InvalidArgumentException("The first name must not be empty");
            }
            $this->firstName = $value;
        }
    }

    public string $lastName {
        set(string $value) {
            $value = trim($value);
            if ($value === "") {
                throw new \InvalidArgumentException("The last name must not be empty");
            }
            $this->lastName = $value;
        }
    }

    // sin un parámetro explícito, el valor recibido se llama [$value]
    public int $age {
        set {
            if ($value < 0) {
                throw new \InvalidArgumentException("The age must be a positive or zero integer");
            }
            $this->age = $value;
        }
    }

    // atributo virtual: solo tiene un hook [get] y no ocupa espacio en el objeto
    public string $identity {
        get => "[$this->firstName,$this->lastName,$this->age]";
    }

    // constructor: las asignaciones pasan por los hooks [set]
    public function __construct(string $firstName, string $lastName, int $age)
    {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
        $this->age = $age;
    }
}

// prueba
$p = new Person(" Paul ", "Langevin", 48);
print "person=$p->identity\n";
// los atributos son públicos: se leen y escriben directamente
$p->age = 49;
print "age=$p->age\n";
// pero la escritura siempre pasa por el hook [set]
foreach (["firstName" => "  ", "age" => -4] as $attribute => $value) {
    try {
        $p->$attribute = $value;
    } catch (\InvalidArgumentException $e) {
        print "Error: " . $e->getMessage() . "\n";
    }
}
// un atributo virtual sin hook [set] no puede escribirse
try {
    $p->identity = "?";
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// el objeto sigue siendo válido
print "person=$p->identity\n";
var_dump($p);

Resultados:

> php classes-23.php
person=[Paul,Langevin,48]
age=49
Error: The first name must not be empty
Error: The age must be a positive or zero integer
Error: Property Person::$identity is read-only
person=[Paul,Langevin,49]
object(Person)#1 (3) {
  ["firstName"]=>
  string(4) "Paul"
  ["lastName"]=>
  string(8) "Langevin"
  ["age"]=>
  int(49)
}

Comentarios

  • líneas 9–17: el atributo público [firstName] va seguido de un bloque entre llaves que contiene sus hooks. Aquí hay un solo hook, [set];
  • línea 10: el hook [set] recibe el valor que se va a asignar al atributo. Lo depura con [trim], lo verifica y lanza una excepción si es incorrecto;
  • línea 15: dentro de sus hooks, [$this->firstName] designa la ubicación de memoria del atributo: allí se almacena el valor. En cualquier otro lugar, [$this->firstName] pasa por los hooks;
  • línea 13: se lanza una excepción de tipo [\InvalidArgumentException]; esta es una clase predefinida derivada de [\Exception] y más específica que ella, que señala un argumento no válido. Trataremos las excepciones predefinidas de PHP en el capítulo sobre excepciones;
  • línea 31: cuando el hook [set] no declara un parámetro, el valor recibido está disponible en la variable implícita [$value], y su tipo es el del atributo;
  • Líneas 40–42: un atributo que tiene un solo hook, [get], y que nunca hace referencia a su propia ubicación de memoria es un atributo virtual: se calcula en cada lectura y no ocupa espacio en el objeto. La notación [get => expression] es una forma abreviada de un hook [get] que se evalúa como el valor de la expresión;
  • líneas 45–50: el constructor asigna los atributos; estas asignaciones se realizan a través de los hooks [set]. Por lo tanto, la validación se efectúa tanto durante la construcción como en cualquier modificación posterior, sin utilizar los métodos [set];
  • línea 54: el nombre [" Paul "] es depurado por el hook [set];
  • línea 57: el atributo [age] se modifica directamente, pero a través de su hook [set];
  • Líneas 60–66: se intenta asignar valores no válidos. La notación [$p->$attribute] usa el contenido de la variable [$attribute] como nombre del atributo. Los hooks [set] lanzan sus excepciones (líneas 4–5 de los resultados);
  • línea 69: el atributo virtual [identity] no tiene un hook [set]: es de solo lectura (línea 6 de los resultados);
  • línea 75: el objeto conservó valores válidos. [var_dump] muestra solo tres atributos: el atributo virtual [identity] no existe en memoria.

Los property hooks existen desde hace tiempo en otros lenguajes (C#, Kotlin, Swift). Eliminan la necesidad de escribir getters y setters “por si acaso”: se empieza con un atributo público simple y se agrega un hook cuando la validación se vuelve necesaria, sin cambiar el código que utiliza la clase.

5.10. Visibilidad asimétrica (PHP 8.4)

Con frecuencia, una propiedad debe poder ser leída por todos, pero modificada únicamente por la propia clase. Antes se escribía una propiedad privada y un getter público. PHP 8.4 permite establecer niveles de visibilidad diferentes para la lectura y la escritura de una propiedad: es lo que se denomina visibilidad asimétrica. El script [classes-24.php] lo demuestra con una cuenta bancaria:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class BankAccount
{
    // visibilidad asimétrica: lectura pública, escritura privada
    public private(set) float $balance = 0.0;

    // la promoción de parámetros también acepta visibilidad asimétrica
    public function __construct(public private(set) string $holder)
    {
    }

    // solo los métodos de la clase pueden modificar el saldo
    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new \InvalidArgumentException("The amount must be positive");
        }
        $this->balance += $amount;
    }

    public function withdraw(float $amount): void
    {
        if ($amount <= 0 || $amount > $this->balance) {
            throw new \InvalidArgumentException("Withdrawal of $amount impossible");
        }
        $this->balance -= $amount;
    }
}

// prueba
$account = new BankAccount("Paul Langevin");
$account->deposit(100);
$account->withdraw(30);
// lectura directa de los atributos, sin getter
print "{$account->holder}: {$account->balance} euros\n";
// la escritura desde fuera de la clase está prohibida
try {
    $account->balance = 1_000_000;
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// la clase conserva el control de la validez del saldo
try {
    $account->withdraw(500);
} catch (\InvalidArgumentException $e) {
    print "Error: " . $e->getMessage() . "\n";
}
print "{$account->holder}: {$account->balance} euros\n";

Resultados:

1
2
3
4
5
> php classes-24.php
Paul Langevin: 70 euros
Error: Cannot modify private(set) property BankAccount::$balance from global scope
Error: Withdrawal of 500 impossible
Paul Langevin: 70 euros

Comentarios

  • Línea 9: el atributo [balance] es público para la lectura ([public]) y privado para la escritura ([private(set)]). El código externo puede leer [$account->balance], pero solo los métodos de la clase pueden modificarlo. También se puede escribir [protected(set)]: en ese caso, las clases derivadas pueden modificar el atributo;
  • línea 12: la visibilidad asimétrica también es posible para un parámetro promovido;
  • líneas 17–25: los métodos [deposit] y [withdraw] son las únicas formas de modificar el saldo. Verifican la validez de las operaciones;
  • línea 39: los atributos se leen directamente, sin getters. La notación [{$expression}] dentro de una cadena entre comillas permite insertar una expresión más compleja que una simple variable;
  • línea 42: escribir en el saldo desde fuera de la clase provoca un error (línea 3 de los resultados). El carácter [_] se puede usar como separador de millares en un número literal (PHP 7.4);
  • Línea 48: el método [withdraw] rechaza el retiro (línea 4 de los resultados). El saldo no ha cambiado (línea 5).

5.11. Atributos y clases de solo lectura ([readonly])

Un objeto cuyo estado no puede cambiar después de su creación se denomina inmutable. Los objetos inmutables simplifican enormemente la programación: se pueden compartir entre varias partes del código sin temor a que alguna de ellas los modifique. PHP 8.1 introdujo los atributos de solo lectura (palabra clave [readonly]): un atributo de este tipo solo puede inicializarse una vez, desde dentro de la clase. PHP 8.2 introdujo las clases de solo lectura: todos sus atributos son entonces [readonly]. El script [classes-25.php] presenta una clase inmutable [Person]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase de solo lectura: todos sus atributos son [readonly]
final readonly class Person
{
    public function __construct(
        public string $firstName,
        public string $lastName,
        public int $age,
    ) {
        if ($age < 0) {
            throw new \InvalidArgumentException("The age must be a positive or zero integer");
        }
    }

    // "modificar" un objeto inmutable = crear una copia modificada
    public function withAge(int $age): static
    {
        // clone con modificación de atributos (PHP 8.5)
        return clone($this, ["age" => $age]);
    }

    public function __toString(): string
    {
        return "[$this->firstName,$this->lastName,$this->age]";
    }
}

// prueba
$p1 = new Person("Paul", "Langevin", 48);
print "p1=$p1\n";
// un atributo [readonly] se inicializa una vez por todas
try {
    $p1->age = 49;
} catch (\Error $e) {
    print "Error 1: " . $e->getMessage() . "\n";
}
// tampoco se pueden agregar atributos a una clase [readonly]
try {
    $p1->address = "Paris";
} catch (\Error $e) {
    print "Error 2: " . $e->getMessage() . "\n";
}
// una nueva persona, copia de la primera con otra edad
$p2 = $p1->withAge(49);
print "p1=$p1\n";
print "p2=$p2\n";

Resultados:

1
2
3
4
5
6
> php classes-25.php
p1=[Paul,Langevin,48]
Error 1: Cannot modify readonly property Person::$age
Error 2: Cannot create dynamic property Person::$address
p1=[Paul,Langevin,48]
p2=[Paul,Langevin,49]

Comentarios

  • línea 7: la clase se declara como [readonly]: sus tres atributos promovidos son de solo lectura. La palabra clave [final], que examinaremos en breve, impide que la clase tenga subclases;
  • Líneas 10–12: los atributos son públicos: se pueden leer directamente, sin getters. No se pueden modificar: un getter no serviría de nada;
  • línea 14: el constructor verifica la validez de la edad. Un objeto inmutable debe ser válido desde su construcción, ya que nunca cambiará;
  • líneas 20–24: “modificar” un objeto inmutable consiste en crear una copia modificada de ese objeto. Es lo que hace el método [withAge]. Su tipo de retorno, [static] (PHP 8.0), significa “un objeto de la clase sobre la cual se llamó al método”. La diferencia con [self] solo se hace evidente con las clases derivadas: si una clase derivada hereda el método, el tipo [static] se refiere a la clase derivada;
  • Línea 23: el operador [clone] crea una copia del objeto [$this]. A partir de PHP 8.5, [clone] se puede usar como una función y aceptar, como segundo parámetro, un arreglo de atributos que se modificarán en la copia (clone with). Antes de PHP 8.5, había que utilizar el método “mágico” [__clone] o reconstruir el objeto con [new];
  • línea 37: modificar un atributo [readonly] provoca un error (línea 3 de los resultados);
  • Línea 43: una clase [readonly] tampoco acepta atributos dinámicos: esto es un error, no una simple advertencia de obsolescencia (línea 4 de los resultados);
  • línea 48: [$p2] es una nueva persona; [$p1] no ha cambiado (líneas 5–6 de los resultados).

En los capítulos siguientes utilizaremos con frecuencia clases [readonly] para representar datos (los datos fiscales del gobierno, los resultados de un cálculo de impuestos, etc.).

5.12. Un arreglo de objetos [Person]

El siguiente ejemplo, [classes-07.php], muestra que es posible tener arreglos de objetos:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

require_once __DIR__ . "/Person.php";
use Examples\Person;

// prueba
// creación de un arreglo de objetos Person
// para facilitar la comprensión del código, no se maneja la posible excepción
$group = [new Person("Paul", "Langevin", 48), new Person("Sylvie", "Lefur", 70)];

// identidad de estas personas
for ($i = 0; $i < count($group); $i++) {
    print "group[$i]=$group[$i]\n";
}

// fin
exit;

Resultados:

1
2
3
> php classes-07.php
group[0]=[Paul,Langevin,48]
group[1]=[Sylvie,Lefur,70]

Comentarios

  • línea 12: creación de un arreglo de 2 personas;
  • línea 15: recorrido del arreglo;
  • Línea 16: [$group[$i]] es un objeto de tipo [Person]. Para mostrarlo se utiliza el método [Person::__toString].

5.13. Creación de una clase derivada de la clase Person

Cree la siguiente clase, [Teacher], en un archivo llamado [Teacher.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// una clase derivada de Person
class Teacher extends Person
{
    // atributo: materia que se enseña
    private string $subject;

    // getter y setter
    public function getSubject(): string
    {
        return $this->subject;
    }

    public function setSubject(string $subject): void
    {
        $this->subject = $subject;
    }

    // constructor
    public function __construct(string $firstName, string $lastName, int $age, string $subject)
    {
        // atributos del padre
        parent::__construct($firstName, $lastName, $age);
        // otros atributos
        $this->setSubject($subject);
    }

    // redefinición del método __toString de la clase padre
    #[\Override]
    public function __toString(): string
    {
        return "[" . parent::__toString() . ",$this->subject]";
    }
}

Comentarios

  • línea 7: la clase [Teacher] también forma parte del espacio de nombres [Examples];
  • Línea 10: la clase [Teacher] se deriva ([extends]) de la clase [Person]. La clase derivada [Teacher] hereda los atributos y los métodos de su clase padre;
  • Línea 13: la clase [Teacher] agrega un nuevo atributo, [subject], que le es propio;
  • línea 27: el constructor de la clase [Teacher] recibe 4 parámetros:
    • 3 para inicializar su clase padre (nombre, apellido, edad), línea 30;
    • 1 para su propia inicialización (la materia), línea 32;
  • línea 30: la clase derivada tiene acceso a los métodos y constructores de su clase padre mediante la palabra clave [parent::]. Aquí, los parámetros (nombre, apellido, edad) se pasan al constructor de la clase padre;
  • línea 36: [#[\Override]] es un atributo de PHP (PHP 8.3). Un atributo, escrito como [#[] and []], es información asociada a una clase, un método, un parámetro, etc., que PHP u otras herramientas pueden utilizar. Este atributo declara que el método siguiente sobrescribe un método de la clase padre. Si no es así (por ejemplo, un error tipográfico en el nombre del método o un método que se eliminó de la clase padre), PHP informa de un error fatal. Veremos un ejemplo un poco más adelante;
  • líneas 37–40: el método [__toString] de la clase derivada utiliza el método [__toString] de la clase padre.

La clase [Teacher] es utilizada por el siguiente script, [classes-08.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión de la definición de las dos clases
require_once __DIR__ . "/Person.php";
require_once __DIR__ . "/Teacher.php";
// declaración de las dos clases usadas
use Examples\Person;
use Examples\Teacher;

// prueba
// creación de un arreglo de objetos Person y objetos derivados
// para simplificar el ejemplo, no se manejan las excepciones
$group = [new Teacher("Paul", "Langevin", 48, "English"), new Person("Sylvie", "Lefur", 70)];

// identidad de estas personas
for ($i = 0; $i < count($group); $i++) {
    print "group[$i]=$group[$i]\n";
}
// fin
exit;

Resultados:

1
2
3
> php classes-08.php
group[0]=[[Paul,Langevin,48],English]
group[1]=[Sylvie,Lefur,70]

Comentarios

  • Líneas 7–8: hay que indicar al intérprete de PHP dónde se encuentran las dos clases [Teacher, Person]. El orden es importante: la clase padre [Person] debe estar definida antes de que se defina la clase [Teacher] ;
  • líneas 10–11: declaración de los nombres completos de las dos clases. Esto nos permitirá referirnos a ellas en el código simplemente por su nombre, sin el prefijo del espacio de nombres;
  • línea 16: creamos un arreglo que contiene un objeto de tipo [Teacher] y un objeto de tipo [Person];
  • líneas 19–21: muestran los elementos del arreglo;
  • línea 20: se llamará al método [__toString] de cada elemento [$group[$i]]. La clase [Person] tiene un método [__toString]. La clase [Teacher] tiene dos: el de su clase padre y el propio. Cabe preguntarse cuál de ellos se llamará. La ejecución muestra que se llamó al de la clase [Teacher]. Esto siempre es así: cuando se llama a un método sobre un objeto, se lo busca en el siguiente orden: en la clase del objeto, en su clase padre si la tiene, luego en la clase padre de la clase padre, y así sucesivamente. La búsqueda se detiene en cuanto se encuentra el método.

5.14. Creación de una segunda clase derivada de la clase Person

El siguiente ejemplo crea una clase llamada [Student] derivada de la clase [Person], en el archivo [Student.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// una segunda clase derivada de Person
class Student extends Person
{
    // atributo: carrera de estudios
    private string $course;

    // getter y setter
    public function getCourse(): string
    {
        return $this->course;
    }

    public function setCourse(string $course): void
    {
        $this->course = $course;
    }

    // constructor
    public function __construct(string $firstName, string $lastName, int $age, string $course)
    {
        // atributos del padre
        parent::__construct($firstName, $lastName, $age);
        // otros atributos
        $this->setCourse($course);
    }

    // redefinición del método __toString de la clase padre
    #[\Override]
    public function __toString(): string
    {
        return "[" . parent::__toString() . ",$this->course]";
    }
}

Esta clase es utilizada por el siguiente script, [classes-09.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// inclusión y declaración de las clases usadas por el script
require_once __DIR__ . "/Person.php";
require_once __DIR__ . "/Teacher.php";
require_once __DIR__ . "/Student.php";
use Examples\{Person, Teacher, Student};

// prueba
// creación de un arreglo de objetos Person y objetos derivados
// para facilitar la comprensión del ejemplo, no se manejan las excepciones
$group = [
    new Teacher("Paul", "Langevin", 48, "English"),
    new Person("Sylvie", "Lefur", 70),
    new Student("Steve", "Boer", 23, "iup2 quality"),
];

// identidad de estas personas
foreach ($group as $i => $person) {
    print "group[$i]=$person (" . $person::class . ")\n";
}
// fin
exit;

Resultados:

1
2
3
4
> php classes-09.php
group[0]=[[Paul,Langevin,48],English] (Examples\Teacher)
group[1]=[Sylvie,Lefur,70] (Examples\Person)
group[2]=[[Steve,Boer,23],iup2 quality] (Examples\Student)

Comentarios

  • Línea 10: una sola instrucción [use] puede declarar varias clases del mismo espacio de nombres si se las encierra entre llaves;
  • Línea 22: el arreglo se recorre con [foreach], que devuelve tanto el índice [$i] como el elemento [$person];
  • línea 23: la notación [$object::class] (PHP 8.0) devuelve el nombre completo de la clase del objeto. Reemplaza a la función [get_class], que está obsoleta cuando se usa sin parámetros desde PHP 8.3.

5.15. Relación entre el constructor de una clase derivada y el de la clase padre

En algunos lenguajes orientados a objetos, el constructor de una clase derivada llama automáticamente al de su clase padre. El siguiente código [classes-16.php] muestra que en PHP no ocurre así:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Class1
{
    // constructor
    public function __construct()
    {
        print "constructor of the Class1 class\n";
    }
}

class Class2 extends Class1
{
    // constructor
    public function __construct()
    {
        // el constructor de la clase padre no se llama implícitamente
        print "constructor of the Class2 class\n";
    }
}

class Class3 extends Class1
{
    // constructor
    public function __construct()
    {
        // llamada explícita al constructor de la clase padre
        parent::__construct();
        // código específico de Class3
        print "constructor of the Class3 class\n";
    }
}

class Class4 extends Class1
{
    // sin constructor: se usa el de la clase padre
}

// pruebas
print "test1---------\n";
new Class2();
print "test2---------\n";
new Class3();
print "test3---------\n";
new Class4();

Resultados:

1
2
3
4
5
6
7
8
> php classes-16.php
test1---------
constructor of the Class2 class
test2---------
constructor of the Class1 class
constructor of the Class3 class
test3---------
constructor of the Class1 class

Comentarios

  • líneas 15–23: el constructor de [Class2] no llama al de su clase padre; el constructor de la clase padre no se ejecuta (línea 3 de los resultados);
  • línea 31: el constructor de [Class3] llama explícitamente al de su clase padre (líneas 5–6 de los resultados);
  • líneas 37–40: la clase [Class4] no tiene constructor. Por lo tanto, hereda el constructor de su clase padre, que se ejecuta (línea 8 de los resultados).

5.16. Sobrescritura de un método de la clase padre

Ya hemos visto que un método de la clase padre puede sobrescribirse en una clase hija. Así, el método [__toString] de la clase [Person] se ha sobrescrito en las clases hijas [Teacher] y [Student]. El script [classes-13.php] ilustra este concepto una vez más:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase principal
class Class1
{
    public function f(): int
    {
        return 1;
    }

    public function g(): int
    {
        return 2;
    }
}

// clase derivada
class Class2 extends Class1
{
    // redefinimos la función f de la clase padre
    #[\Override]
    public function f(): int
    {
        return parent::f() + 10;
    }
}

// código
$c2 = new Class2();
print $c2->f() . "\n";
print $c2->g() . "\n";
$c1 = new Class1();
print $c1->f() . "\n";

Resultados:

1
2
3
4
> php classes-13.php
11
2
1

Comentarios

  • líneas 7–18: la clase [Class1] define dos métodos, f y g;
  • líneas 21–29: la clase [Class2] extiende la clase [Class1] y redefine su método f. El atributo [#[\Override]] documenta esta redefinición;
  • línea 32: crea un objeto [$c2] de tipo [Class2];
  • línea 33: llama al método f del objeto [$c2]. Como este método existe en la clase [Class2], se ejecuta. A su vez, este llama al método f de la clase padre mediante la notación [parent::f()];
  • línea 34: llama al método g del objeto [$c2]. Como este método no existe en la clase [Class2], se busca en la clase padre, donde se encuentra y se ejecuta;
  • línea 35: crea un objeto [$c1] de tipo [Class1];
  • línea 36: llama al método f del objeto [$c1]. Se ejecuta el método f de la clase [Class1].

Veamos ahora la utilidad del atributo [#[\Override]]. En el script [classes-10.php], el desarrollador quería redefinir el método f pero usó un nombre incorrecto:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase principal
class Class1
{
    public function f(): int
    {
        return 1;
    }
}

// clase derivada
class Class2 extends Class1
{
    // creemos que estamos redefiniendo el método f de la clase padre
    // pero nos equivocamos de nombre: el atributo [Override] lo detecta
    #[\Override]
    public function F2(): int
    {
        return parent::f() + 10;
    }
}

// código
$c2 = new Class2();
print $c2->f() . "\n";

Resultados:

1
2
3
4
5
> php classes-10.php

Fatal error: Class2::F2() has #[\Override] attribute, but no matching parent method exists in .../php8-oct-2026/scripts-console/classes/classes-10.php on line 21
Stack trace:
#0 {main}

Sin el atributo [#[\Override]], el método [F2] sería simplemente un nuevo método de [Class2], y el script mostraría [1] sin señalar ninguna anomalía: el error pasaría inadvertido. Con el atributo, PHP rechaza la clase en cuanto se carga (línea 3 de los resultados). En el resto de este curso utilizaremos sistemáticamente [#[\Override]] en los métodos redefinidos.

5.17. Paso de un objeto como parámetro de una función

Consideremos el siguiente script [classes-14.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase principal
class Class1
{
    public function f(): int
    {
        return 1;
    }

    public function g(): int
    {
        return 2;
    }
}

// clase derivada
class Class2 extends Class1
{
    // redefinimos la función f de la clase padre
    #[\Override]
    public function f(): int
    {
        return parent::f() + 10;
    }
}

// el parámetro de la función es de tipo Class1 o derivado
function doSomething(Class1 $c1): void
{
    print $c1->f() + $c1->g() . "\n";
}

// código
// creamos un objeto de tipo Class2 derivado de Class1
$c2 = new Class2();
// llamamos a doSomething con un objeto de tipo Class2
doSomething($c2);
// un objeto de otro tipo es rechazado
try {
    doSomething(new \stdClass());
} catch (\TypeError $e) {
    print "Error: " . $e->getMessage() . "\n";
}

Resultados:

1
2
3
> php classes-14.php
13
Error: doSomething(): Argument #1 ($c1) must be of type Class1, stdClass given, called in .../php8-oct-2026/scripts-console/classes/classes-14.php on line 44

Comentarios

  • líneas 7–18: la clase [Class1];
  • líneas 21–29: una clase [Class2] derivada de [Class1];
  • línea 32: una función que espera un parámetro de tipo [Class1]. Cuando el tipo esperado es una clase, el parámetro real puede ser un objeto del tipo esperado o de un tipo derivado;
  • línea 41: se llama a la función [doSomething] con un parámetro de tipo [Class2], aunque el tipo esperado es [Class1]. Esto se acepta porque [Class2] deriva de [Class1] (línea 2 de los resultados);
  • línea 44: un objeto de tipo [stdClass] no es de tipo [Class1]: la llamada provoca un error de tipo [TypeError] (línea 3 de los resultados).

5.18. Clases abstractas

Una clase abstracta es una clase incompleta que no puede instanciarse. Debe derivarse para poder utilizarse.

¿Cuál es la utilidad de una clase abstracta? A veces tenemos clases que comparten uno o varios métodos, pero difieren en otros métodos o atributos. En tales casos, conviene agrupar todo lo que tienen en común en una clase padre. Por ahora no necesitamos una clase abstracta. Pero supongamos que las clases hijas difieren solo en un método, M: la firma del método sería la misma en todas las clases hijas, pero su implementación sería distinta. Para obligar a las clases hijas a implementar el método M:

  • declararemos la firma del método M en la clase padre. Como la clase padre no sabe cómo implementarlo, anteponemos al método la palabra clave [abstract]: esto significa que la implementación del método M se delega a las clases hijas;
  • como la clase padre no está completamente implementada, también se declara abstracta con la misma palabra clave [abstract]. Esto significa que la clase ya no puede instanciarse. Hay que crear una clase hija que defina la implementación del método M para poder utilizar el cuerpo de la clase padre.

Este es un ejemplo [classes-15.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase principal abstracta
abstract class Class1
{
    // método conocido por todas las clases derivadas
    public function f(): int
    {
        return 1;
    }

    // método abstracto g - será definido por las clases derivadas
    abstract public function g(): int;
}

// clase derivada
class Class2 extends Class1
{
    // el método g de la clase padre debe estar definido
    #[\Override]
    public function g(): int
    {
        return parent::f() + 10;
    }
}

// clase derivada
class Class3 extends Class1
{
    // el método g de la clase padre debe estar definido
    #[\Override]
    public function g(): int
    {
        return parent::f() + 20;
    }

    // podemos redefinir el método f de la clase padre
    #[\Override]
    public function f(): int
    {
        return 2;
    }
}

// código
$c2 = new Class2();
print $c2->f() . "\n";
print $c2->g() . "\n";
$c3 = new Class3();
print $c3->f() . "\n";
print $c3->g() . "\n";
// una clase abstracta no puede instanciarse
try {
    new Class1();
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}

Resultados:

1
2
3
4
5
6
> php classes-15.php
1
11
2
21
Error: Cannot instantiate abstract class Class1

Comentarios

  • líneas 7–17: la clase [Class1] es abstracta porque no implementa el método g de la línea 16. Por lo tanto, debe derivarse de otra clase para poder utilizarse;
  • líneas 20–28: la clase [Class2] extiende la clase [Class1] y define el método g de su clase padre. El atributo [#[\Override]] también se aplica a la implementación de un método abstracto;
  • líneas 31–46: la clase [Class3] extiende la clase [Class1] y define el método g de su clase padre;
  • líneas 40–44: la clase [Class3] también redefine el método f de su clase padre;
  • líneas 49–54: se crean dos objetos de tipos [Class2] y [Class3] , y se llama a sus métodos f y g;
  • línea 57: una clase abstracta no puede instanciarse; se produce un error (línea 6 de los resultados).

5.19. Clases finales

Una clase final es una clase de la que no se puede derivar. Consideremos el siguiente script, [classes-11.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// clase que no puede derivarse
final class Class1
{
}

// clase derivada - provoca un error
class Class2 extends Class1
{
}

// código
new Class2();

Resultados:

1
2
3
4
5
> php classes-11.php

Fatal error: Class Examples\Class2 cannot extend final class Examples\Class1 in .../php8-oct-2026/scripts-console/classes/classes-11.php on line 15
Stack trace:
#0 {main}

Comentarios

  • línea 10: la palabra clave [final] convierte la clase [Class1] en una clase final de la que no se puede derivar;
  • línea 15: la clase [Class2] extiende la clase final [Class1], lo cual es un error;
  • El error se informa en cuanto el intérprete de PHP carga la definición de la clase [Class2]: es un error fatal que no se puede interceptar con un [try / catch]. El script no se ejecuta.

Declarar una clase como [final] es una buena práctica cuando no fue diseñada para ser derivada; esto evita que otros desarrolladores dependan de los detalles internos de la clase.

5.20. Métodos finales

Un método final es un método que una subclase no puede sobrescribir. Este es un ejemplo, [classes-12.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// clase principal
class Class1
{
    // este método no puede redefinirse en una clase derivada
    final public function f(): int
    {
        return 1;
    }
}

// clase derivada
class Class2 extends Class1
{
    // redefinición prohibida - provoca un error
    public function f(): int
    {
        return 2;
    }
}

// código
new Class2();

Resultados:

1
2
3
4
5
> php classes-12.php

Fatal error: Cannot override final method Examples\Class1::f() in .../php8-oct-2026/scripts-console/classes/classes-12.php on line 23
Stack trace:
#0 {main}

Comentarios

  • línea 13: el método f de la clase [Class1] se declara final mediante la palabra clave ***[final]***;
  • línea 20: la clase [Class2] extiende la clase [Class1];
  • línea 23: se redefine el método f de la clase padre [Class1] . Esto provoca un error fatal, que se informa en cuanto se carga la clase [Class2].

5.21. Métodos y atributos estáticos

Un método estático es un método asociado a la clase en la que se define, y no a los objetos instancia de la clase. Así, si la clase C declara un método estático M, para usarlo desde fuera de la clase se escribiría:

  • [C::M] si se está fuera de la clase;
  • [self::M] si se está dentro de la clase.

Este es un ejemplo: [classes-17.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Class1
{
    // método estático
    public static function say(string $message): void
    {
        print "$message\n";
    }

    // método estático que usa otro método estático de la clase
    public static function sayTwice(string $message): void
    {
        self::say($message);
        self::say($message);
    }
}

// prueba ───────────────
Class1::say("hello");
Class1::sayTwice("good morning");
// sintaxis de callable de primera clase: [Class1::say(...)] es una función
$speak = Class1::say(...);
$speak("hi");
// que se puede pasar a otra función
array_map($speak, ["one", "two"]);

Resultados:

1
2
3
4
5
6
7
> php classes-17.php
hello
good morning
good morning
hi
one
two

Comentarios

  • línea 9: el método [say] se declara estático mediante la palabra clave [static];
  • línea 17: dentro de la clase, el método estático [say] se llama mediante la notación [self::say];
  • línea 23: el método estático [say] se llama mediante la notación [Class1::say];
  • línea 26: sintaxis de callable de primera clase (PHP 8.1): escribir [(...)] en lugar de los argumentos de una llamada no realiza la llamada, sino que devuelve la propia función, en forma de objeto [Closure]. La variable [$speak] contiene entonces una función que se llama igual que una función ordinaria (línea 27). La misma sintaxis se aplica a las funciones ([strlen(...)]) y a los métodos de objeto ([$p->identity(...)]);
  • línea 29: una función de este tipo puede pasarse como argumento a otra función. La función [array_map] aplica la función [$speak] a cada elemento del arreglo (líneas 6–7 de los resultados).

Consideremos ahora el siguiente código, [classes-18.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Class1
{
    // atributo estático
    private static int $nbObjects = 0;

    public function __construct()
    {
        print "Class1 constructor\n";
        self::$nbObjects++;
    }

    // método estático
    public static function say(): void
    {
        print self::$nbObjects . " objects of type [Class1] have been built\n";
    }
}

// prueba ───────────────
new Class1();
new Class1();
Class1::say();

Resultados:

1
2
3
4
> php classes-18.php
Class1 constructor
Class1 constructor
2 objects of type [Class1] have been built

Comentarios

  • Línea 9: se declara un atributo estático para contar el número de instancias de la clase [Class1] que se han creado. Este no es un atributo que pueda pertenecer a una instancia de la clase. En efecto, si se crean dos objetos, O1 y O2, ninguno sabe de la existencia del otro. Tener un contador en la instancia no tiene sentido: cuando se crea un nuevo objeto, ¿en qué instancia se incrementaría el contador? Un atributo estático es un atributo de clase, no un atributo de instancia de la clase;
  • líneas 11–15: el constructor es el lugar donde contamos los objetos creados, ya que la creación de cada nuevo objeto desencadena la ejecución del constructor;
  • línea 14: observe la notación [self::$nbObjects], que indica que nos referimos a un atributo estático de la clase en la que reside el código que se ejecuta;
  • líneas 18–21: el método estático [say] se encarga de mostrar el número de objetos creados;
  • Líneas 25–27: se crean dos objetos y se muestra el contador de objetos.

5.22. Visibilidad entre clases padre e hija

Examinemos el siguiente script, [classes-19.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class SomeParent
{
    // atributo
    private int $attributeOfParent = 4;

    // método
    public function doTest(): void
    {
        // ¿quién llama?
        print "parent:\n";
        var_dump($this);
        // visualización del padre
        print "parent: attributeOfParent={$this->attributeOfParent}\n";
        print "parent: attributeOfChild={$this->attributeOfChild}\n";
    }
}

class SomeChild extends SomeParent
{
    // atributo
    private int $attributeOfChild = 14;

    // método
    #[\Override]
    public function doTest(): void
    {
        // visualización del hijo
        print "child: attributeOfParent={$this->attributeOfParent}\n";
        print "child: attributeOfChild={$this->attributeOfChild}\n";
        // padre
        parent::doTest();
    }
}

// script principal
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();

Comentarios

  • Líneas 6–21: la clase [SomeParent];
  • Líneas 23–38: la clase hija [SomeChild]. Vemos que extiende la clase [SomeParent];
  • línea 9: la clase [SomeParent] tiene un solo atributo;
  • Líneas 12–20: el método [SomeParent::doTest] está diseñado para mostrar dos atributos:
    • [$attributeOfParent], que pertenece a la clase [SomeParent];
    • [$attributeOfChild], que pertenece a la clase [SomeChild];
  • Líneas 15–16: se muestra la identidad de quien llama; el método se llamará de dos maneras diferentes:
    • desde la clase padre [SomeParent];
    • desde la clase hija [SomeChild];
  • líneas 18–19: muestran los dos atributos;
  • línea 26: la clase [SomeChild] tiene un solo atributo;
  • línea 30: el método [SomeChild::doTest] está diseñado para mostrar dos atributos:
    • [$attributeOfParent], que pertenece a la clase [SomeParent];
    • [$attributeOfChild], que pertenece a la clase [SomeChild];
  • Líneas 33–34: visualización de los dos atributos;
  • línea 36: llama al método [doTest] de la clase padre, que a su vez muestra ambos atributos;
  • línea 42: se llama al método [SomeParent::doTest] ;
  • línea 44: se llama al método [SomeChild::doTest].

En la primera prueba, la visibilidad de ambos atributos es [private]. Por lo tanto, cabe esperar que la clase hija no vea el atributo de su clase padre. Ese atributo necesitaría tener al menos la visibilidad [protected]. Pero ¿qué ocurre con el atributo de la clase hija? ¿Es visible en la clase padre?

Estos son los resultados de esta primera prueba:

> php classes-19.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
  ["attributeOfParent":"SomeParent":private]=>
  int(4)
}
parent: attributeOfParent=4

Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 19
parent: attributeOfChild=
---------------------------test2

Warning: Undefined property: SomeChild::$attributeOfParent in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 33
child: attributeOfParent=
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
  ["attributeOfParent":"SomeParent":private]=>
  int(4)
  ["attributeOfChild":"SomeChild":private]=>
  int(14)
}
parent: attributeOfParent=4

Fatal error: Uncaught Error: Cannot access private property SomeChild::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-19.php:19
Stack trace:
#0 .../php8-oct-2026/scripts-console/classes/classes-19.php(36): SomeParent->doTest()
#1 .../php8-oct-2026/scripts-console/classes/classes-19.php(44): SomeChild->doTest()
#2 {main}
  thrown in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 19

Comentarios

  • líneas 2–11: resultados de la primera prueba, en la que se llama al método [SomeParent::doTest];
  • líneas 3–7: vemos que el objeto que llama al método es de tipo [SomeParent];
  • línea 8: se muestra el atributo [$attributeOfParent];
  • líneas 10–11: vemos que el atributo [SomeParent::$attributeOfChild] no existe. Por lo tanto, no se muestra. En PHP 8, leer un atributo inexistente provoca una advertencia de nivel [Warning] (en PHP 7 era un simple [Notice] );
  • líneas 12–31: resultados de la segunda prueba, en la que se llama al método [SomeChild::doTest];
  • líneas 14–15: vemos que el atributo [SomeChild::$attributeOfParent] no existe. Por lo tanto, no se muestra. Es normal: el atributo [SomeParent::$attributeOfParent] es [private] y, por lo tanto, no se reconoce en la clase hija;
  • línea 16: se muestra el atributo [$attributeOfChild];
  • Líneas 17–31: estamos en el método [SomeParent::doTest] llamado por la clase hija;
  • líneas 18–23: vemos que [$this] es de tipo [SomeChild] con dos atributos privados;
  • línea 24: sorprendentemente, [$this]—que es de tipo [SomeChild]—puede ver el atributo privado de su clase padre, [$attributeOfParent];
  • Líneas 26–31: de igual modo sorprendente, [$this], que es de tipo [SomeChild], no puede acceder a su atributo [$attributeOfChild]: el intento de acceder a él provoca un error fatal.

Este resultado es muy sorprendente: aunque las líneas 18–23 indican que [$this] es de tipo [SomeChild], este [$this] dentro del método [SomeParent::doTest] se comporta como si fuera una instancia de la clase [SomeParent] y no de la clase [SomeChild]. En realidad, la visibilidad se comprueba con relación a la clase en la que está escrito el código (aquí, [SomeParent]) y no con relación a la clase del objeto.

Hagamos una nueva prueba con el script [classes-20.php]. El atributo [$attributeOfParent] ahora tiene la visibilidad [protected]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class SomeParent
{
    // atributo
    protected int $attributeOfParent = 4;

    // método
    public function doTest(): void
    {
        // ¿quién llama?
        print "parent:\n";
        var_dump($this);
        // visualización del padre
        print "parent: attributeOfParent={$this->attributeOfParent}\n";
        print "parent: attributeOfChild={$this->attributeOfChild}\n";
    }
}

class SomeChild extends SomeParent
{
    // atributo
    private int $attributeOfChild = 14;

    // método
    #[\Override]
    public function doTest(): void
    {
        // visualización del hijo
        print "child: attributeOfParent={$this->attributeOfParent}\n";
        print "child: attributeOfChild={$this->attributeOfChild}\n";
        // padre
        parent::doTest();
    }
}

// script principal
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();

Resultados:

> php classes-20.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
  ["attributeOfParent":protected]=>
  int(4)
}
parent: attributeOfParent=4

Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-20.php on line 19
parent: attributeOfChild=
---------------------------test2
child: attributeOfParent=4
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
  ["attributeOfParent":protected]=>
  int(4)
  ["attributeOfChild":"SomeChild":private]=>
  int(14)
}
parent: attributeOfParent=4

Fatal error: Uncaught Error: Cannot access private property SomeChild::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-20.php:19
Stack trace:
#0 .../php8-oct-2026/scripts-console/classes/classes-20.php(36): SomeParent->doTest()
#1 .../php8-oct-2026/scripts-console/classes/classes-20.php(44): SomeChild->doTest()
#2 {main}
  thrown in .../php8-oct-2026/scripts-console/classes/classes-20.php on line 19

Comentarios

  • Línea 13: la clase [SomeChild] ahora puede ver el atributo de su clase padre, [$attributeOfParent]. Esto es normal, ya que el padre tiene ahora un ámbito [protected];
  • En el método [SomeParent::doTest], el objeto [$this] es de tipo [SomeChild] (líneas 16–21). Puede ver el atributo de su clase padre, [$attributeOfParent] (línea 22), pero sigue sin poder ver su propio atributo privado, [$attributeOfChild] (líneas 24–29).

En el tercer intento, [classes-21.php], el atributo [$attributeOfChild] también tiene un ámbito [protected]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class SomeParent
{
    // atributo
    protected int $attributeOfParent = 4;

    // método
    public function doTest(): void
    {
        // ¿quién llama?
        print "parent:\n";
        var_dump($this);
        // visualización del padre
        print "parent: attributeOfParent={$this->attributeOfParent}\n";
        print "parent: attributeOfChild={$this->attributeOfChild}\n";
    }
}

class SomeChild extends SomeParent
{
    // atributo
    protected int $attributeOfChild = 14;

    // método
    #[\Override]
    public function doTest(): void
    {
        // visualización del hijo
        print "child: attributeOfParent={$this->attributeOfParent}\n";
        print "child: attributeOfChild={$this->attributeOfChild}\n";
        // padre
        parent::doTest();
    }
}

// script principal
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();

Los resultados de la ejecución son los siguientes:

> php classes-21.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
  ["attributeOfParent":protected]=>
  int(4)
}
parent: attributeOfParent=4

Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-21.php on line 19
parent: attributeOfChild=
---------------------------test2
child: attributeOfParent=4
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
  ["attributeOfParent":protected]=>
  int(4)
  ["attributeOfChild":protected]=>
  int(14)
}
parent: attributeOfParent=4
parent: attributeOfChild=14
  • Línea 23: esta vez, dentro del padre, [$this], que es de tipo [SomeChild] (líneas 16–21), ve el atributo protegido [$attributeOfChild] de su propia clase, [SomeChild].

¿Qué podemos aprender de estas pruebas?

  • Que la instancia [$this] de una clase padre, utilizada en un método de la clase padre, puede ver:
    • los atributos y métodos de la clase padre, sea cual sea su visibilidad;
    • no ve ninguno de los atributos ni métodos de sus clases hijas;
  • este es el comportamiento esperado;
  • que la instancia [$this] de una clase hija, utilizada en un método de la clase hija, ve:
    • los atributos y métodos de la clase padre si tienen al menos visibilidad [protected]. Los que tienen visibilidad [private] no son visibles;
    • los atributos y métodos de la clase hija, sea cual sea su visibilidad;
  • este es el comportamiento esperado;
  • la instancia [$this] de una clase hija, utilizada en un método de la clase padre, ve:
    • los atributos y métodos de la clase padre, sea cual sea su visibilidad;
    • los atributos y métodos de su propia clase solo si tienen al menos visibilidad [protected]. Los que tienen visibilidad [private] no son visibles;
  • Este es un comportamiento inesperado, que se explica por la regla enunciada anteriormente: la visibilidad depende de la clase en la que está escrito el código.

5.23. Enumeraciones (PHP 8.1)

Una persona tiene un género: femenino o masculino. ¿Cómo se puede representar esta información? En PHP 7 se utilizaba una cadena (["F"], ["M"]) o constantes de clase. En aquel entonces, nada impedía pasar un valor incorrecto (["X"], ["female"]...). PHP 8.1 introdujo las enumeraciones (palabra clave [enum]): una enumeración es un tipo que tiene solo un número finito de valores posibles, llamados casos. Definimos la enumeración [Gender] en el archivo [Gender.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// espacio de nombres
namespace Examples;

// una enumeración respaldada por cadenas de caracteres (backed enum)
enum Gender: string
{
    case Female = "F";
    case Male = "M";

    // una enumeración puede tener métodos
    public function label(): string
    {
        return match ($this) {
            Gender::Female => "Madam",
            Gender::Male => "Sir",
        };
    }
}

Comentarios

  • Línea 10: la enumeración [Gender]. El tipo [string] que sigue a su nombre la convierte en una enumeración “con valores asociados” (backed): cada caso está asociado a un valor escalar, en este caso una cadena. Este valor es útil para almacenar el caso en un archivo o en una base de datos. Sin este tipo, es una enumeración pura cuyos casos no tienen valores asociados;
  • líneas 12–13: los dos casos de la enumeración y sus valores;
  • líneas 16–22: una enumeración puede tener métodos (así como constantes y métodos estáticos). Dentro de un método, ***[$this]*** se refiere al caso sobre el que se llama al método;
  • líneas 18–21: la expresión [match] (PHP 8.0) compara su parámetro con los valores de cada rama mediante el operador [===] y devuelve el valor de la primera rama que coincide. Si ninguna rama coincide, se lanza un error [UnhandledMatchError]. Aquí están definidas todas las ramas.

La enumeración es utilizada por el script [classes-26.php]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

require_once __DIR__ . "/Gender.php";
use Examples\Gender;

// una persona con un género
final readonly class Person
{
    public function __construct(
        public string $firstName,
        public string $lastName,
        public Gender $gender,
    ) {
    }

    public function __toString(): string
    {
        return "{$this->gender->label()} $this->firstName $this->lastName";
    }
}

// prueba
$p1 = new Person("Paul", "Langevin", Gender::Male);
$p2 = new Person("Sylvie", "Lefur", Gender::Female);
print "$p1\n$p2\n";
// un caso de enumeración tiene un nombre y un valor
print "name={$p2->gender->name}, value={$p2->gender->value}\n";
// los casos son objetos únicos: se comparan con ===
print "p1 is a man: " . var_export($p1->gender === Gender::Male, true) . "\n";
// la lista de los casos
foreach (Gender::cases() as $gender) {
    print "$gender->name ($gender->value): {$gender->label()}\n";
}
// de un valor (leído de un archivo, una base de datos...) a un caso
print "from('F'): " . Gender::from("F")->name . "\n";
print "tryFrom('X'): " . var_export(Gender::tryFrom("X"), true) . "\n";
try {
    Gender::from("X");
} catch (\ValueError $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// el tipo [Gender] solo acepta los casos de la enumeración
try {
    new Person("Steve", "Boer", "M");
} catch (\TypeError $e) {
    print "Error: " . $e->getMessage() . "\n";
}

Resultados:

> php classes-26.php
Sir Paul Langevin
Madam Sylvie Lefur
name=Female, value=F
p1 is a man: true
Female (F): Madam
Male (M): Sir
from('F'): Female
tryFrom('X'): NULL
Error: "X" is not a valid backing value for enum Examples\Gender
Error: Person::__construct(): Argument #3 ($gender) must be of type Examples\Gender, string given, called in .../php8-oct-2026/scripts-console/classes/classes-26.php on line 47

Comentarios

  • línea 15: el atributo [gender] de la clase [Person] es de tipo [Gender];
  • línea 21: llamada al método [label] de la instancia almacenada en el atributo [gender];
  • línea 26: un caso se designa con la notación [Gender::Male];
  • línea 30: cada caso tiene un atributo [name], su nombre, y, en una enumeración con valores asociados, un atributo [value], su valor (línea 4 de los resultados);
  • línea 32: cada caso es un objeto único: los casos se comparan mediante el operador [===];
  • línea 34: el método estático [cases] devuelve la lista de casos de la enumeración (líneas 6–7 de los resultados);
  • línea 38: el método estático [from] devuelve el caso asociado a un valor. Es el proceso inverso de [value]: ["F"] se lee de una base de datos y se obtiene el caso [Gender::Female];
  • línea 39: el método [tryFrom] devuelve [null] si el valor no corresponde a ningún caso;
  • línea 41: el método [from], en cambio, lanza un error [ValueError] (línea 10 de los resultados);
  • línea 47: el tipo [Gender] acepta solo los casos de la enumeración, no sus valores: ["M"] es rechazado (línea 11 de los resultados). Este es todo el sentido de las enumeraciones: un valor incorrecto se detecta de inmediato.

5.24. Codificación JSON de una clase

En una clase, el método [__toString] suele estar presente: se supone que devuelve una cadena que representa al objeto que lo llama. Puede resultar tentador hacer que esta cadena sea una cadena JSON. Exploraremos ahora este enfoque. Los scripts se encuentran en la carpeta [scripts-console/classes/json]:

1
2
3
4
5
6
7
8
9
php8-oct-2026/scripts-console/classes/json
├── json-01.php
├── json-02.php
├── json-03.php
├── json-04.php
├── Person.php
├── Person2.php
├── Person3.php
└── Person4.php

Utilizaremos la siguiente clase [Person]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

class Person
{
    // atributos
    private ?string $lastName = null;
    private ?string $firstName = null;
    private ?int $age = null;
    private ?array $children = null;

    // setter global
    public function setFromArray(array $arrayOfAttributes): static
    {
        // inicialización de algunos atributos de la clase
        foreach ($arrayOfAttributes as $attribute => $value) {
            // los atributos no declarados en la clase son rechazados
            if (!property_exists($this, $attribute)) {
                throw new \InvalidArgumentException("Unknown attribute [$attribute]");
            }
            $this->$attribute = $value;
        }
        // devolvemos el objeto
        return $this;
    }

    // getters
    public function getLastName(): ?string
    {
        return $this->lastName;
    }

    public function getFirstName(): ?string
    {
        return $this->firstName;
    }

    public function getAge(): ?int
    {
        return $this->age;
    }

    public function getChildren(): ?array
    {
        return $this->children;
    }


    // __toString
    public function __toString(): string
    {
        // identificamos el objeto
        var_dump($this);
        // recuperamos sus atributos
        $attributes = \get_object_vars($this);
        var_dump($attributes);
        // devolvemos la cadena JSON de los atributos
        return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
    }
}

Comentarios

  • líneas 9–12: los cuatro atributos de la clase. Son tipos que admiten valores nulos ([?string] significa [string] o [null]) y se inicializan en [null];
  • líneas 30–45: los getters que permiten obtener los valores de estos atributos;
  • líneas 15–27: un setter global que inicializa los atributos a partir de un arreglo asociativo ***[$arrayOfAttributes],*** cuyas claves coinciden con los nombres de los atributos de la clase;
  • línea 20: la función [property_exists] verifica que el atributo esté declarado en la clase. Sin esta verificación, una clave desconocida crearía un atributo dinámico, lo cual está obsoleto desde PHP 8.2;
  • Línea 23: la notación [$this->$attribute] hace referencia al atributo cuyo nombre es el valor de la variable [$attribute];
  • línea 15: el método devuelve el objeto actual [$this]. Su tipo de retorno es [static]: “un objeto de la clase sobre la cual se llamó al método”. Esto permite llamadas encadenadas: [(new Person())->setFromArray([...])];
  • Líneas 52–61: el método [__toString] de la clase;
  • línea 57: la función de PHP [get_object_vars] obtiene los valores de los atributos del objeto en forma de arreglo asociativo [['lastName'=>'lastName1', 'firstName'=>'firstName1', 'age'=>age1, 'children'=>[...]]]. Cuando se llama desde dentro de la clase, también devuelve los atributos privados;
  • línea 60: se devuelve la cadena JSON de este arreglo de atributos. La opción [JSON_UNESCAPED_UNICODE] especifica que los caracteres acentuados no deben convertirse en secuencias [é].

Examinemos el script [json-01.php], que utiliza la clase [Person]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase Person
require_once __DIR__ . "/Person.php";

// instanciación del padre
$father = new Person();
// inicialización del padre
$father->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Dieudonné",
    "age" => 58,
]);
// instanciación e inicialización de child1
$child1 = (new Person())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Sylvain",
    "age" => 17,
]);
// instanciación e inicialización de child2
$child2 = (new Person())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Géraldine",
    "age" => 12,
]);
// inicialización de los hijos del padre
$father->setFromArray([
    "children" => [$child1, $child2],
]);

// visualización de los elementos del padre
$child1 = $father->getChildren()[0];
$child2 = $father->getChildren()[1];
print "------------------------child1\n";
print "child1=$child1\n";
print "------------------------child2\n";
print "child2=$child2\n";
print "------------------------father\n";
print "father=$father\n";

Comentarios

  • líneas 10–16: un objeto de tipo [Person] [$father] se inicializa mediante el método [Person::setFromArray];
  • líneas 18–22: un objeto [Person] [$child1] se inicializa de la misma manera;
  • líneas 24–28: se inicializa un objeto [Person] [$child2] ;
  • línea 31: el atributo [children] del padre se inicializa con un arreglo que contiene a los dos hijos;
  • líneas 35–36: se obtienen los dos hijos del padre;
  • línea 38: la operación [print] intenta convertir el objeto [$child1] en una cadena. Para ello utiliza el método [__toString] del objeto. Por lo tanto, esperamos ver la cadena JSON del objeto;
  • línea 42: hacemos lo mismo con el padre.

Los resultados son los siguientes:

> php json-01.php
------------------------child1
object(Person)#2 (4) {
  ["lastName":"Person":private]=>
  string(11) "Bertholomé"
  ["firstName":"Person":private]=>
  string(7) "Sylvain"
  ["age":"Person":private]=>
  int(17)
  ["children":"Person":private]=>
  NULL
}
array(4) {
  ["lastName"]=>
  string(11) "Bertholomé"
  ["firstName"]=>
  string(7) "Sylvain"
  ["age"]=>
  int(17)
  ["children"]=>
  NULL
}
child1={"lastName":"Bertholomé","firstName":"Sylvain","age":17,"children":null}
------------------------child2
object(Person)#3 (4) {
  ["lastName":"Person":private]=>
  string(11) "Bertholomé"
  ["firstName":"Person":private]=>
  string(10) "Géraldine"
  ["age":"Person":private]=>
  int(12)
  ["children":"Person":private]=>
  NULL
}
array(4) {
  ["lastName"]=>
  string(11) "Bertholomé"
  ["firstName"]=>
  string(10) "Géraldine"
  ["age"]=>
  int(12)
  ["children"]=>
  NULL
}
child2={"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}
------------------------father
object(Person)#1 (4) {
  ["lastName":"Person":private]=>
  string(11) "Bertholomé"
  ["firstName":"Person":private]=>
  string(10) "Dieudonné"
  ["age":"Person":private]=>
  int(58)
  ["children":"Person":private]=>
  array(2) {
    [0]=>
    object(Person)#2 (4) {
      ["lastName":"Person":private]=>
      string(11) "Bertholomé"
      ["firstName":"Person":private]=>
      string(7) "Sylvain"
      ["age":"Person":private]=>
      int(17)
      ["children":"Person":private]=>
      NULL
    }
    [1]=>
    object(Person)#3 (4) {
      ["lastName":"Person":private]=>
      string(11) "Bertholomé"
      ["firstName":"Person":private]=>
      string(10) "Géraldine"
      ["age":"Person":private]=>
      int(12)
      ["children":"Person":private]=>
      NULL
    }
  }
}
array(4) {
  ["lastName"]=>
  string(11) "Bertholomé"
  ["firstName"]=>
  string(10) "Dieudonné"
  ["age"]=>
  int(58)
  ["children"]=>
  array(2) {
    [0]=>
    object(Person)#2 (4) {
      ["lastName":"Person":private]=>
      string(11) "Bertholomé"
      ["firstName":"Person":private]=>
      string(7) "Sylvain"
      ["age":"Person":private]=>
      int(17)
      ["children":"Person":private]=>
      NULL
    }
    [1]=>
    object(Person)#3 (4) {
      ["lastName":"Person":private]=>
      string(11) "Bertholomé"
      ["firstName":"Person":private]=>
      string(10) "Géraldine"
      ["age":"Person":private]=>
      int(12)
      ["children":"Person":private]=>
      NULL
    }
  }
}
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{},{}]}

Comentarios

  • líneas 3–12: el objeto [$child1];
  • Líneas 13–22: el arreglo de atributos del objeto [$child1]. Los tenemos todos;
  • línea 23: tenemos la cadena JSON del objeto [$child1];
  • líneas 24–45: lo mismo para el objeto [$child2];
  • líneas 46–113: para el padre es un poco diferente, ya que su atributo [children] no es [null], como lo era en el caso de los hijos;
  • línea 113: vemos que, en la cadena JSON del padre, los hijos son objetos vacíos [{}];
  • Líneas 80–112: vemos que, en la tabla de atributos del padre, el hijo 1 sigue siendo un objeto, al igual que el hijo 2. En resumen, la expresión [\get_object_vars($this)]—donde [$this] representa al padre—no es recursiva: si un atributo de la clase [Person] es a su vez un objeto, la expresión [\get_object_vars($this)] no intenta obtener su arreglo de atributos. Por otra parte, la función [json_encode] codifica únicamente los atributos públicos de un objeto: los hijos, cuyos atributos son todos privados, se convierten en objetos JSON vacíos.

Podemos mejorar esto. Modificamos la clase [Person] para obtener la siguiente clase [Person2]:

    // __toString
    public function __toString(): string
    {
        // recuperamos los atributos del objeto
        $attributes = $this->getAttributes();
        $children = $attributes["children"];
        if ($children !== null) {
            $attributes["children"] = [$children[0]->getAttributes(), $children[1]->getAttributes()];
        }
        // devolvemos la cadena JSON de los atributos
        return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
    }

    public function getAttributes(): array
    {
        return \get_object_vars($this);
    }
}

Comentarios

  • líneas 64–67: el método [getAttributes] devuelve el arreglo de atributos del objeto que lo llama;
  • líneas 52–62: el método [__toString];
  • Línea 55: obtenemos los atributos del objeto a partir del arreglo [$attributes];
  • línea 56: por el ejemplo anterior sabemos que [$attributes["children"]] es un arreglo de dos objetos de tipo [Person2];
  • Líneas 57–59: los dos objetos se reemplazan por su arreglo de atributos;
  • línea 61: solo queda codificar como JSON el arreglo de atributos construido.

El script [json-02.php] utiliza la clase [Person2] de la siguiente manera:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase Person2
require_once __DIR__ . "/Person2.php";

// instanciación del padre
$father = new Person2();
// inicialización del padre
$father->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Dieudonné",
    "age" => 58,
]);
// instanciación e inicialización de child1
$child1 = (new Person2())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Sylvain",
    "age" => 17,
]);
// instanciación e inicialización de child2
$child2 = (new Person2())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Géraldine",
    "age" => 12,
]);
// inicialización de los hijos del padre
$father->setFromArray([
    "children" => [$child1, $child2],
]);

// visualización del padre
print "------------------------father\n";
print "father=$father\n";

El script [json-02.php] es idéntico al script [json-01.php], salvo que la clase [Person2] ha reemplazado a la clase [Person] y solo se muestra el padre. Los resultados de la ejecución son los siguientes:

1
2
3
> php json-02.php
------------------------father
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{"lastName":"Bertholomé","firstName":"Sylvain","age":17,"children":null},{"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}]}

Esta vez, los hijos se muestran correctamente junto con el padre.

La solución anterior no es satisfactoria porque los hijos pueden tener a su vez hijos propios. Esto nos devuelve al problema anterior. La clase [Person3] resuelve este problema de la siguiente manera:

    // __toString
    public function __toString(): string
    {
        // devolvemos la cadena JSON de los atributos
        $attributes = [];
        $this->getRecursiveAttributes($attributes, $this, []);
        // cadena JSON de los atributos
        return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
    }

    public function getAttributes(): array
    {
        return \get_object_vars($this);
    }

    private function getRecursiveAttributes(array &$attributes, mixed $value, array $keys): void
    {
        // análisis del valor [$value]
        // $keys es un arreglo [key1, key2, .., keyn]
        // $value=$attributes[key1][key2]...[keyn]
        // si [$value] es un objeto usamos su método [getAttributes]
        if (\is_object($value)) {
            // atributos del objeto [$value]
            $objectAttributes = $value->getAttributes();
            // ¿hay claves?
            if ($keys) {
                // en [$attributes], vamos a reemplazar $value por el arreglo de sus atributos
                // debemos construir el elemento $attributes[key1][key2]...[keyn]
                // donde $keys es el arreglo [key1, key2, .., keyn]
                // tomamos la referencia del arreglo [$attributes]
                $attribute = &$attributes;
                // recorremos el arreglo de claves
                foreach ($keys as $key) {
                    // tomamos la referencia del atributo
                    $attribute = &$attribute[$key];
                }
                // aquí $attribute y $attributes[key1][key2]...[keyn] son idénticos
                // comparten la misma ubicación de memoria
                // el objeto [$value] se reemplaza por su arreglo de atributos:
                // debemos escribir $attributes[key1][key2]...[keyn]=$objectAttributes
                // lo cual equivale a $attribute = $objectAttributes
                $attribute = $objectAttributes;
            } else {
                // sin claves - estamos al inicio de la exploración del objeto
                // $objectAttributes representa los atributos de 1.er nivel de la clase
                $attributes += $objectAttributes;
            }
            // quizás todavía haya objetos en [$objectAttributes]
            // exploramos los atributos de [$objectAttributes]
            $this->getRecursiveAttributes($attributes, $objectAttributes, $keys);
        } elseif (\is_array($value)) {
            // tenemos un arreglo - analizamos cada uno de sus elementos
            foreach ($value as $key => $element) {
                // agregamos la clave actual al arreglo $keys
                $keys[] = $key;
                // analizamos $element
                $this->getRecursiveAttributes($attributes, $element, $keys);
                // eliminamos del arreglo $keys la clave que acaba de analizarse
                \array_pop($keys);
            }
        }
    }
}

Comentarios

  • línea 56: esta vez, el método [__toString] obtiene los atributos de su clase y exige que se haga de forma recursiva: si un atributo es un objeto o un arreglo de objetos, cada objeto debe reemplazarse por su arreglo de atributos en el arreglo final de atributos de la clase;
  • Líneas 66–112: el método [getRecursiveAttributes] realiza esta tarea. Hemos comentado su código. Escribir una función recursiva suele ser complejo. Es el caso aquí. El lector no se perderá nada si no la entiende: veremos en breve que PHP ofrece una solución mucho más sencilla. La llamada recursiva se produce en las líneas 100 y 107;
  • la ventaja de este código es que no se escribió únicamente para la clase [Person3]. Se aplica a cualquier clase con atributos cuyos valores sean objetos de diferentes tipos, siempre que las clases utilizadas por la clase principal tengan también, al igual que la propia clase principal, el método [getAttributes] de las líneas 61–64.

El script [json-03.php] utiliza la clase [Person3] de la siguiente manera:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase Person3
require_once __DIR__ . "/Person3.php";

// instanciación del padre
$father = new Person3();
// inicialización del padre
$father->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Dieudonné",
    "age" => 58,
]);
// instanciación e inicialización de child1
$child1 = (new Person3())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Sylvain",
    "age" => 27,
]);
// instanciación e inicialización de child2
$child2 = (new Person3())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Géraldine",
    "age" => 12,
]);
// inicialización de los hijos del padre
$father->setFromArray([
    "children" => [$child1, $child2],
]);
// instanciación e inicialización de child11
$child11 = (new Person3())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Gaëtan",
    "age" => 2,
]);
// instanciación e inicialización de child12
$child12 = (new Person3())->setFromArray([
    "lastName" => "Bertholomé",
    "firstName" => "Mathilde",
    "age" => 1,
]);
// inicialización de los hijos de child1
$child1->setFromArray([
    "children" => [$child11, $child12],
]);
// visualización del padre
print "------------------------father\n";
print "father=$father\n";
  • líneas 34–47: se asignan dos hijos a [$child1].

Los resultados de la ejecución son los siguientes:

1
2
3
> php json-03.php
------------------------father
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{"lastName":"Bertholomé","firstName":"Sylvain","age":27,"children":[{"lastName":"Bertholomé","firstName":"Gaëtan","age":2,"children":null},{"lastName":"Bertholomé","firstName":"Mathilde","age":1,"children":null}]},{"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}]}

Se han obtenido correctamente las cadenas JSON de todos los objetos [Person3] que componen al padre.

5.24.1. La interfaz [JsonSerializable]

Existe una solución mucho más sencilla, proporcionada por PHP: la interfaz predefinida [JsonSerializable]. Examinaremos las interfaces en el próximo capítulo. Por ahora, basta con señalar que una clase que “implementa” la interfaz [JsonSerializable] debe definir un método [jsonSerialize(): mixed]. Cuando la función [json_encode] encuentra un objeto de esta clase, llama a su método [jsonSerialize] y codifica el valor devuelto en lugar del objeto. Lo hace en todos los niveles del árbol de datos. La clase [Person4] utiliza esta interfaz:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// la clase implementa la interfaz predefinida [JsonSerializable]
class Person4 implements \JsonSerializable
{
    // constructor con promoción de parámetros
    public function __construct(
        private string $lastName,
        private string $firstName,
        private int $age,
        // arreglo de objetos [Person4]
        private array $children = [],
    ) {
    }

    // agrega un hijo y devuelve el objeto actual para encadenar las llamadas
    public function addChild(Person4 $child): static
    {
        $this->children[] = $child;
        return $this;
    }

    // método de la interfaz [JsonSerializable]:
    // devuelve el valor que [json_encode] debe codificar en lugar del objeto
    #[\Override]
    public function jsonSerialize(): mixed
    {
        return \get_object_vars($this);
    }

    // __toString: la cadena JSON del objeto
    public function __toString(): string
    {
        return \json_encode($this, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);
    }
}

Comentarios

  • línea 7: la clase implementa la interfaz [JsonSerializable];
  • líneas 10–16: un constructor con promoción de parámetros reemplaza al setter global. El arreglo de hijos está vacío por defecto;
  • líneas 20–24: agrega un hijo y devuelve el objeto actual (tipo de retorno [static]) para permitir llamadas encadenadas;
  • línea 29: el método exigido por la interfaz. Su tipo de retorno es [mixed] (PHP 8.0), que significa “cualquier tipo”. Aquí devuelve el arreglo de atributos del objeto. Los hijos siguen siendo objetos [Person4]: [json_encode] llamará a su propio método, [jsonSerialize]. PHP se encarga de la recursión;
  • línea 28: el atributo [#[\Override]] también se aplica a un método impuesto por una interfaz;
  • línea 37: se llama directamente a [json_encode] sobre el objeto. Se combinan tres opciones con el operador [|]:
    • [JSON_UNESCAPED_UNICODE]: los caracteres acentuados se escriben tal cual;
    • [JSON_PRETTY_PRINT]: la cadena JSON se formatea en varias líneas, con sangría;
    • [JSON_THROW_ON_ERROR] (PHP 7.3): en caso de error, [json_encode] lanza una excepción [JsonException] en lugar de devolver [false]. Esto es importante aquí: el método [__toString] debe devolver una cadena y no puede devolver [false].

El script [json-04.php] utiliza la clase [Person4]:

<?php

// respeto estricto de los tipos declarados de los parámetros de las funciones
declare(strict_types=1);

// clase Person4
require_once __DIR__ . "/Person4.php";

// el padre, sus hijos y sus nietos
$child1 = (new Person4("Bertholomé", "Sylvain", 27))
    ->addChild(new Person4("Bertholomé", "Gaëtan", 2))
    ->addChild(new Person4("Bertholomé", "Mathilde", 1));
$father = (new Person4("Bertholomé", "Dieudonné", 58))
    ->addChild($child1)
    ->addChild(new Person4("Bertholomé", "Géraldine", 12));

// visualización del padre: [json_encode] llama a [jsonSerialize] en cada objeto que encuentra
print "------------------------father\n";
print "father=$father\n";
// una cadena JSON compacta, sin escapar los caracteres acentuados
print "------------------------json_encode\n";
print json_encode($child1, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR) . "\n";
// decodificación: obtenemos un arreglo asociativo (2.º parámetro en true), no un objeto [Person4]
print "------------------------json_decode\n";
$data = json_decode((string) $father, true, flags: JSON_THROW_ON_ERROR);
print "first name of the 1st grandchild: {$data['children'][0]['children'][0]['firstName']}\n";
// una cadena JSON incorrecta provoca una excepción [JsonException]
print "------------------------error\n";
try {
    json_decode('{"lastName": "Bertholomé"', flags: JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
    print "Error: " . $e->getMessage() . "\n";
}
// sin [JSON_THROW_ON_ERROR], el error es silencioso
var_dump(json_decode('{"lastName": "Bertholomé"'));
print "json_last_error_msg: " . json_last_error_msg() . "\n";

Resultados:

> php json-04.php
------------------------father
father={
    "lastName": "Bertholomé",
    "firstName": "Dieudonné",
    "age": 58,
    "children": [
        {
            "lastName": "Bertholomé",
            "firstName": "Sylvain",
            "age": 27,
            "children": [
                {
                    "lastName": "Bertholomé",
                    "firstName": "Gaëtan",
                    "age": 2,
                    "children": []
                },
                {
                    "lastName": "Bertholomé",
                    "firstName": "Mathilde",
                    "age": 1,
                    "children": []
                }
            ]
        },
        {
            "lastName": "Bertholomé",
            "firstName": "Géraldine",
            "age": 12,
            "children": []
        }
    ]
}
------------------------json_encode
{"lastName":"Bertholomé","firstName":"Sylvain","age":27,"children":[{"lastName":"Bertholomé","firstName":"Gaëtan","age":2,"children":[]},{"lastName":"Bertholomé","firstName":"Mathilde","age":1,"children":[]}]}
------------------------json_decode
first name of the 1st grandchild: Gaëtan
------------------------error
Error: Syntax error
NULL
json_last_error_msg: Syntax error

Comentarios

  • líneas 10–12: construcción de [$child1] y de sus dos hijos mediante llamadas encadenadas;
  • línea 19: el método [__toString] del padre produce una cadena JSON formateada que contiene a todos los descendientes (líneas 3–34 de los resultados). No escribimos ningún código recursivo;
  • línea 22: sin [JSON_PRETTY_PRINT], la cadena JSON es compacta (línea 36 de los resultados);
  • línea 25: la función [json_decode] realiza la operación inversa: transforma una cadena JSON en un valor de PHP. Con un segundo parámetro igual a [true], los objetos JSON se convierten en arreglos asociativos. Observe que esto devuelve arreglos y no objetos [Person4]: reconstruir objetos a partir de una cadena JSON requiere código adicional (o una biblioteca como el componente [Serializer] de Symfony). El argumento con nombre [flags:] evita tener que pasar el tercer parámetro [depth];
  • línea 30: la cadena JSON es incorrecta (falta la llave de cierre). Con [JSON_THROW_ON_ERROR], se lanza una excepción [JsonException] (línea 40 de los resultados);
  • línea 35: sin [JSON_THROW_ON_ERROR], [json_decode] devuelve [null] sin informar de ningún error (línea 41). Habría que consultar entonces la función [json_last_error_msg] para saber si se produjo un error. Por eso utilizaremos sistemáticamente la opción [JSON_THROW_ON_ERROR] en el resto de este curso.