Skip to content

9. Traits

Los traits son estructuras análogas a las clases. Sin embargo, no se pueden instanciar: están destinados a incluirse en clases. Incluir un trait en una clase tiene el mismo efecto que si el código del trait se hubiera copiado en la clase. El código que puede reutilizarse en varias clases se coloca en un trait.

Los traits existen desde PHP 5.4. PHP 8 introdujo varias novedades, que veremos al final de este capítulo: verificación de firmas para métodos abstractos (PHP 8.0), constantes en traits (PHP 8.2), el atributo [#[\Override]] utilizable en un trait (PHP 8.3).

9.1. Estructura de directorios de los scripts

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

1
2
3
4
5
6
php8-oct-2026/scripts-console/traits
├── trait-01.php
├── trait-02.php
├── ...
├── trait-09.php
└── trait-10.php

9.2. Inclusión de un trait en una clase

El script [trait-01.php] muestra un uso básico de un trait en una clase:

<?php

declare(strict_types=1);

class Class04
{
    // constructor con promoción del atributo [name]
    public function __construct(private string $name)
    {
    }

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

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

trait Trait04
{
    // atributo
    private string $name;

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

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

class Class05
{
    // inclusión del trait
    use Trait04;

    // constructor
    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

// prueba ──────────────
$class04 = new Class04("Tim");
$class05 = new Class05("Burton");
print $class04->getName() . "\n";
print $class05->getName() . "\n";
// visualización de los dos objetos
print_r($class04);
print_r($class05);

Comentarios del código

  • líneas 5–22: definición de la clase [Class04] con un atributo [$name] (inicializado por el constructor), su getter y su setter;
  • líneas 24–39: tomamos el código de [Class04]—sin su constructor— y lo trasladamos al trait [Trait04]. Esta vez el atributo se declara explícitamente, junto con su tipo. No incluimos el constructor, ya que un trait no se puede instanciar;
  • línea 24: la palabra clave [trait] designa a [Trait04] como un trait y no como una clase;
  • líneas 41–51: definimos una clase [Class05] que incluye el código del trait [Trait04] y le agrega un constructor, para que la clase sea instanciable;
  • línea 44: la palabra clave [use], colocada dentro de una clase, permite incluir un trait en ella. No debe confundirse con la instrucción [use], que se coloca fuera de cualquier clase e importa un nombre de un espacio de nombres;
  • líneas 54–60: las pruebas muestran que las clases [Class04] y [Class05] funcionan de la misma manera.

Resultados

> php trait-01.php
Tim
Burton
Class04 Object
(
    [name:Class04:private] => Tim
)
Class05 Object
(
    [name:Class05:private] => Burton
)

Los resultados de las líneas 4–11 muestran que los objetos [Class04] y [Class05] tienen el mismo contenido: el atributo privado [$name] del trait se ha convertido en un atributo privado de la clase [Class05].

Conclusión: usar la instrucción [use Trait] en una clase equivale a incluir en ella el código de [Trait] .

9.3. Uso del mismo trait en diferentes clases

Uno de los principales beneficios de un trait parece ser la reutilización del mismo código (atributos + métodos) en diferentes clases. Sin embargo, veremos que el mismo objetivo puede lograrse con clases simples.

El siguiente script, [trait-02.php], ilustra cómo compartir un trait entre clases:

<?php

declare(strict_types=1);

trait Trait01
{
    // atributo
    private int $id = 0;

    // método
    public function doSomething(): void
    {
        print "Trait01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // inclusión de Trait01
    use Trait01 {
        // el método [Trait01::doSomething] es accesible
        // en la clase con el nombre [doSomethingInTrait]
        Trait01::doSomething as doSomethingInTrait;
    }

    // método propio de la clase
    public function doSomething(): void
    {
        // atributo id
        $this->id += 10;
        // uso del método de Trait01
        $this->doSomethingInTrait();
        // visualización local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // inclusión de Trait01
    use Trait01;

    // método local de la clase
    public function doSomethingElse(): void
    {
        // atributo id
        $this->id += 10;
        // uso del método de Trait01
        $this->doSomething();
        // visualización local
        print "Class03->doSomethingElse\n";
    }
}

// test01 ────────────────
function test01(): void
{
    $class02 = new Class02();
    $class03 = new Class03();
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();

Comentarios

  • líneas 5–15: un trait que define un atributo [$id] y un método [doSomething];
  • el trait [Trait01] se incluye en dos clases: [Class02] (líneas 17–36) y [Class03] (líneas 38–53);
  • líneas 20–24: inclusión de [Trait01] en [Class02]. A la inclusión le sigue un bloque [{...}] que permite ajustar los métodos incluidos;
  • línea 23: esta línea resuelve un conflicto: [Trait01] y [Class02] tienen ambos un método llamado [doSomething]. En este caso, el método de la clase tiene prioridad: el método del trait queda oculto. El operador [as] hace que el método [Trait01::doSomething] sea accesible en la clase con el nombre [doSomethingInTrait]. Así, dentro de [Class02], se usarán las siguientes notaciones:
    • [doSomethingInTrait] para llamar al método [Trait01::doSomething];
    • [doSomething] para llamar al método [Class02::doSomething];
  • líneas 30–32: la clase [Class02] usa el atributo y el método de [Trait01] como si fueran propios;
  • líneas 38–53: la clase [Class03] es análoga a la clase [Class02]. La inclusión de [Trait01] es aquí más sencilla porque no hay conflicto entre los métodos de [Trait01] y de [Class03].

Resultados

1
2
3
4
5
6
> php trait-02.php
test01-----------------
Trait01::doSomething... (10)
Class02->doSomething
Trait01::doSomething... (10)
Class03->doSomethingElse

Observe que el trait [Trait01] no se comparte entre las clases [Class02] y [Class03]. El atributo [$id] de [Trait01] se convierte, debido a la inclusión de [Trait01] en las clases [Class02] y [Class03], en dos atributos distintos: [Class02::$id] y [Class03::$id]. Esto se muestra en las líneas 3 y 5 de los resultados. Si el atributo [$id] se hubiera compartido entre las clases [Class02] y [Class03], el valor de la línea 5 habría sido 20 en lugar de 10.

El script [trait-03.php] muestra que puede obtenerse el mismo resultado usando una clase en lugar del trait:

<?php

declare(strict_types=1);

// clase que reemplaza al trait
class Class01
{
    // atributo
    private int $id = 0;

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

    // getter
    public function getId(): int
    {
        return $this->id;
    }

    // método
    public function doSomething(): void
    {
        print "Class01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // una referencia a una instancia de Class01, inyectada por el constructor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método propio de la clase
    public function doSomething(): void
    {
        // modificación del atributo de Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // uso del método de Class01
        $this->class01->doSomething();
        // visualización local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // una referencia a una instancia de Class01, inyectada por el constructor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método local de la clase
    public function doSomethingElse(): void
    {
        // modificación del atributo de Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // uso del método de Class01
        $this->class01->doSomething();
        // visualización local
        print "Class03->doSomethingElse\n";
    }
}

// test01 ────────────────
function test01(): void
{
    // dos objetos que accederán a dos instancias distintas de [Class01]
    $class02 = new Class02(new Class01());
    $class03 = new Class03(new Class01());
    // verificación
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test02 ────────────────
function test02(): void
{
    // instancia compartida de [Class01]
    $class01 = new Class01();
    // dos objetos que accederán a la misma instancia de [Class01]
    $class02 = new Class02($class01);
    $class03 = new Class03($class01);
    // verificación
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();
// test02
print "test02-----------------\n";
test02();

Comentarios

  • Líneas 6–28: la clase [Class01] reemplaza al trait [Trait01]. El código de [Trait01] se incorporaba al código de las clases [Class02] y [Class03]. Aquí no ocurrirá así: se inyectará una referencia a un objeto [Class01] en las clases [Class02] y [Class03] . Los atributos de la clase [Class01] serán, por lo tanto, externos a los objetos [Class02] y [Class03] . Como el atributo [$id] es privado, es necesario proporcionar un getter y un setter. Esta es la primera diferencia con un trait: hay que crear código para acceder a los atributos privados de la clase. Podríamos haber hecho público el atributo [$id], pero no se recomienda: usar un setter para asignar el valor de un atributo permite validarlo;
  • línea 33: la referencia al objeto *[Class01] se inyecta en *[Class02] mediante su constructor, gracias a la promoción de parámetros. El curso de PHP 7 usaba un setter [setClass01]. La inyección por el constructor es preferible: el objeto [Class02] está completo desde que se construye y, como el atributo es [readonly], la referencia ya no puede cambiarse;
  • líneas 41–45: para cualquier uso del código de [Class01], debemos pasar por el atributo [$this->class01];
  • líneas 51–70: la clase [Class03] es un clon de la clase [Class02], salvo que su método tiene un nombre distinto;
  • líneas 73–81: la primera prueba. Consiste en inyectar dos instancias distintas de la clase [Class01] en los objetos [Class02] y [Class03];
  • líneas 84–94: la segunda prueba inyecta la misma instancia de la clase [Class01] en los objetos [Class02] y [Class03].

Resultados

> php trait-03.php
test01-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (10)
Class03->doSomethingElse
test02-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (20)
Class03->doSomethingElse

Comentarios sobre los resultados

  • líneas 3–6: obtenemos los mismos resultados que con el trait [Trait01]. Podemos concluir que aquí el uso del trait no es indispensable, pero sí reduce la cantidad de código, porque no se necesitan métodos para acceder a los atributos del trait: estos forman parte integral de la clase en la que se incorporó el trait;
  • líneas 8–11: como se inyectó la misma referencia a [Class01] en los objetos [Class02] y [Class03], el atributo [Class01::$id] se compartió entre los dos objetos. Por eso la línea 10 de los resultados muestra 20 en lugar de 10 cuando se usa el trait. Podemos concluir que, si se necesita compartir atributos entre objetos, no se puede usar el trait y debe usarse una clase en su lugar.

9.4. Agrupación de métodos en un trait

En el ejemplo anterior, el trait incluía atributos y métodos. Aquí consideraremos el caso en que contiene solo métodos. El trait se parece entonces a una factorización de métodos que pueden usarse en distintas clases. Como aquí el trait no tiene atributos, consideraremos el caso en que los métodos que contiene operan únicamente sobre los parámetros que reciben. Esto no es obligatorio: un trait puede operar sobre un atributo [$this->attribute1] sin tener él mismo ese atributo. En ese caso, corresponde a las clases que usan el trait proporcionar el atributo [$this->attribute1].

Cuando el trait solo tiene métodos que operan únicamente sobre los parámetros que reciben, mostraremos que el trait puede sustituirse por una clase con los mismos métodos que el trait, declarados como estáticos.

El uso del trait se ilustra con el script [trait-04.php], que reutiliza el trait del ejemplo anterior pero elimina todos los atributos:

<?php

declare(strict_types=1);

trait Trait01
{
    // método a compartir
    public function doSomething(): void
    {
        print "Trait01::doSomething...\n";
    }
}

class Class02
{
    // inclusión de Trait01
    use Trait01 {
        // el método [Trait01::doSomething] es accesible
        // en la clase con el nombre [doSomethingInTrait]
        Trait01::doSomething as doSomethingInTrait;
    }

    public function doSomething(): void
    {
        // llamada al método de Trait01
        $this->doSomethingInTrait();
        // visualización local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // inclusión de Trait01
    use Trait01;

    // método local de la clase
    public function doSomethingElse(): void
    {
        // llamada al método de Trait01
        $this->doSomething();
        // visualización local
        print "Class03->doSomethingElse\n";
    }
}

// prueba ────────────────
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

Comentarios

  • líneas 5–12: el trait [Trait01] ya no tiene atributos;
  • líneas 17–21: [Trait01] se incluye en [Class02]. El método de [Trait01] se usa en la línea 26;
  • línea 35: [Trait01] se incluye en [Class03]. El método de [Trait01] se usa en la línea 41.

Resultados

1
2
3
4
5
> php trait-04.php
Trait01::doSomething...
Class02->doSomething
Trait01::doSomething...
Class03->doSomethingElse

En este caso de uso, el trait [Trait01] puede sustituirse fácilmente por una clase. Lo demuestra el siguiente script [trait-05.php]:

<?php

declare(strict_types=1);

// clase no instanciable ni derivable, que contiene solo métodos estáticos
final class Class01
{
    // constructor privado: ninguna instanciación posible fuera de la clase
    private function __construct()
    {
    }

    // método estático a compartir
    public static function doSomething(): void
    {
        print "Class01::doSomething...\n";
    }
}

class Class02
{
    public function doSomething(): void
    {
        // llamada al método estático de Class01
        Class01::doSomething();
        // visualización local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // método local de la clase
    public function doSomethingElse(): void
    {
        // llamada al método estático de Class01
        Class01::doSomething();
        // visualización local
        print "Class03->doSomethingElse\n";
    }
}

// prueba ────────────────
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

Comentarios

  • líneas 6–18: el trait [Trait01] se sustituye por una clase [Class01], todos cuyos métodos son estáticos. No es necesario instanciarla ni derivarla. En el curso de PHP 7 se la declaraba abstracta para impedir su instanciación, lamentando que PHP rechace el prefijo [final abstract]. Esto sigue siendo así en PHP 8: en su lugar, declaramos la clase [final] (no derivable) con un constructor privado (no instanciable). Es lo que hicimos con la clase [Utilities] en la versión 3 del ejercicio de aplicación;
  • línea 25: en lugar de escribir [$this->doSomethingInTrait()], ahora escribimos [Class01::doSomething()], es decir, llamamos al método estático [doSomething] de la clase [Class01];
  • línea 37: se repite el mismo procedimiento en [Class03].

Resultados

1
2
3
4
5
> php trait-05.php
Class01::doSomething...
Class02->doSomething
Class01::doSomething...
Class03->doSomethingElse

Efectivamente obtenemos el mismo resultado que con el trait [Trait01], lo que demuestra que su uso puede evitarse. Observamos que los métodos de un trait pueden operar sobre un atributo [$this->attribute1] aunque el trait mismo no tenga ese atributo; corresponde a las clases que usan el trait proporcionarlo. Es un escenario exótico y frágil: es mejor “subir” el atributo [$this->attribute1] al propio trait. De ese modo, formará necesariamente parte de los atributos de la clase que usa el trait. Veremos al final del capítulo que PHP 8 ofrece una solución limpia para exigir algo a las clases que usan un trait: los métodos abstractos.

9.5. Herencia múltiple con un trait

Es común leer en la literatura que los traits permiten la herencia múltiple: la capacidad de una clase de heredar de varias clases. El lenguaje C++ admite esta característica, pero ni Java ni C# lo hacen, ya que solo admiten la herencia simple. Mostraremos que, si bien usar un trait en una clase derivada permite implementar algo parecido a la herencia múltiple, este caso de uso también puede implementarse con clases simples.

El script [trait-06.php] implementa una clase derivada y un trait:

<?php

declare(strict_types=1);

trait Trait01
{
    // atributo
    private int $i = 0;

    // método a compartir
    public function doSomethingInTrait01(): void
    {
        // modificación de Trait01::$i
        $this->i++;
        // visualización
        print "Trait01::doSomethingInTrait01... i=$this->i\n";
    }
}

class Class02
{
    // atributo accesible para las clases derivadas
    protected int $j = 0;

    // método
    public function doSomethingInClass02(): void
    {
        // modificación de Class02::$j
        $this->j += 10;
        // visualización
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

// clase derivada
class Class03 extends Class02
{
    // hereda Class02::$j e incluye Trait01::$i
    use Trait01;

    // método
    public function doSomethingInClass03(): void
    {
        // uso del método de Trait01
        $this->doSomethingInTrait01();
        // modificación de Trait01::$i
        $this->i += 100;
        // modificación de Class03::$j (==Class02::$j)
        $this->j += 1000;
        // visualización
        print "Class03->doSomethingInClass03... i=$this->i, j=$this->j\n";
    }
}

// prueba ────────────────
(new Class02())->doSomethingInClass02();
(new Class03())->doSomethingInClass03();

Comentarios

  • líneas 5–18: un trait [Trait01] con un atributo y un método que lo manipula;
  • líneas 20–33: una clase [Class02] que no tiene nada que ver con el trait [Trait01]. No lo usa;
  • línea 23: el único atributo de [Class02] tiene la visibilidad [protected] para que sea accesible en las clases derivadas;
  • línea 36: la clase [Class03] extiende la clase [Class02]. Además, incorpora el trait [Trait01] (línea 39). Por lo tanto, hereda los atributos y métodos de [Class02] e incorpora los atributos y métodos de [Trait01]. Esto es, entonces, análogo a la herencia múltiple.

Resultados

1
2
3
4
> php trait-06.php
Class02->doSomethingInClass02... j=10
Trait01::doSomethingInTrait01... i=1
Class03->doSomethingInClass03... i=101, j=1000

Al igual que en un ejemplo anterior, mostraremos que:

  • el trait puede sustituirse por una clase;
  • en lugar de incorporar el trait en la clase derivada, le inyectamos una referencia a una instancia de esa clase.

El script [trait-07.php] es el siguiente:

<?php

declare(strict_types=1);

class Class01
{
    // atributo
    private int $i = 0;

    // getter y setter
    public function getI(): int
    {
        return $this->i;
    }

    public function setI(int $i): void
    {
        $this->i = $i;
    }

    // método
    public function doSomethingInClass01(): void
    {
        // modificación de Class01::$i
        $this->i++;
        // visualización
        print "Class01->doSomethingInClass01... i=$this->i\n";
    }
}

class Class02
{
    // atributo accesible para las clases derivadas
    protected int $j = 0;

    // método propio de la clase
    public function doSomethingInClass02(): void
    {
        // modificación de Class02::$j
        $this->j += 10;
        // visualización
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

class Class03 extends Class02
{
    // una referencia a una instancia de Class01, inyectada por el constructor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método local de la clase
    public function doSomethingInClass03(): void
    {
        // uso del método de Class01
        $this->class01->doSomethingInClass01();
        // modificación de Class01::$i
        $i = $this->class01->getI();
        $i += 100;
        $this->class01->setI($i);
        // modificación de Class03::$j
        $this->j += 1000;
        // visualización
        print "Class03->doSomethingInClass03... i=$i, j=$this->j\n";
    }
}

// prueba ────────────────
$class02 = new Class02();
$class03 = new Class03(new Class01());
$class02->doSomethingInClass02();
$class03->doSomethingInClass03();

Comentarios

  • líneas 5–29: la clase *[Class01] sustituye al trait *[Trait01]. Como un objeto [Class01] se usará mediante una referencia, se proporcionaron un getter y un setter para el atributo [$i];
  • líneas 31–44: la clase [Class02] permanece sin cambios;
  • línea 46: la clase [Class03] extiende la clase [Class02];
  • línea 49: se inyecta en [Class03] una referencia a un objeto [Class01] mediante su constructor;
  • líneas 54–66: el método [doSomethingInClass03] hace lo mismo que antes, pero con un código más complejo.

Resultados

1
2
3
4
> php trait-07.php
Class02->doSomethingInClass02... j=10
Class01->doSomethingInClass01... i=1
Class03->doSomethingInClass03... i=101, j=1000

De este ejemplo podemos concluir que, una vez más, el trait no es indispensable, pero hay que reconocer que permite un código más corto en la clase derivada.

9.6. Uso de un trait en lugar de una clase abstracta

El siguiente caso de uso es común: se crea una interfaz I bastante general que puede dar lugar a varias implementaciones. Estas implementaciones comparten código común pero difieren en otros métodos. Hay dos maneras de implementar este caso de uso:

  • Se crea una clase abstracta C que contiene el código común a las clases derivadas. La clase C implementa la interfaz I, pero ciertos métodos —que deben definirse en las clases derivadas— se declaran abstractos en la clase C, que por lo tanto es a su vez abstracta. Luego se crean las clases C1 y C2 derivadas de C, cada una de las cuales implementa a su manera los métodos abstractos de su clase padre C;
  • se crea un trait T casi idéntico a la clase abstracta C de la solución anterior. Este trait no implementa la interfaz I porque, sintácticamente, no puede. Luego se crean las clases C1 y C2, que implementan la interfaz I y usan el trait T. A estas clases solo les resta implementar los métodos de la interfaz I que no están implementados por el trait T que importan.

A continuación se presenta un ejemplo que ilustra cuán parecidas son estas dos soluciones. La aplicación 1 implementa la solución 1 ([trait-08.php]):

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

abstract class AbstractClass implements Interface1
{
    // atributos accesibles para las clases derivadas
    protected int $attr1 = 11;
    protected int $attr2 = 12;

    // getters y setters
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // método implementado
    #[\Override]
    public function doSomething(): void
    {
        print "AbstractClass::doSomething [$this->attr1,$this->attr2]\n";
    }

    // método no implementado
    #[\Override]
    abstract public function doSomethingElse(): void;
}

// clase derivada 1
class Class1 extends AbstractClass
{
    // atributo
    private int $attr3 = 13;

    // getter y setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // implementación de doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// clase derivada 2
class Class2 extends AbstractClass
{
    // atributo
    private int $attr4 = 14;

    // getter y setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // implementación de doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// función externa
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// pruebas
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// los setters "fluidos" pueden encadenarse
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

Comentarios

  • líneas 5–10: la interfaz [Interface1] tiene dos métodos;
  • línea 12: la clase abstracta [AbstractClass] implementa la interfaz [Interface1]. Tiene dos atributos con sus getters y setters, implementa el método [doSomething] de la interfaz [Interface1] (línea 43), pero no implementa el método [doSomethingElse]. Por lo tanto, este método se declara abstracto (línea 50). La clase abstracta [AbstractClass] no puede instanciarse y, para ser útil, debe derivarse;
  • líneas 29–39: los setters son “fluidos”: en lugar de no devolver nada, devuelven el objeto [$this]. Esto permite encadenar llamadas (línea 116). El tipo de retorno [static] (PHP 8.0) se refiere a la clase del objeto sobre el que se llamó al método: [(new Class1())->setAttr1(21)] es de tipo [Class1] y no [AbstractClass], lo que permite llamar a continuación a [setAttr3]—un método específico de [Class1]—;
  • línea 54: la clase [Class1] extiende la clase abstracta [AbstractClass] y por lo tanto implementa la interfaz [Interface1]. Proporciona un cuerpo para el método [doSomethingElse], que su clase padre no había definido. También agrega un atributo a los de su clase padre;
  • línea 80: la clase [Class2] hace lo mismo con otro atributo;
  • líneas 106–110: la función [useInterfaceWith] recibe como parámetro un tipo [Interface1] y llama a los dos métodos de esta interfaz;
  • líneas 113–116: se llama a la función [useInterfaceWith] con un tipo [Class1] y luego con un tipo [Class2]. Esto es correcto porque ambos tipos implementan la interfaz [Interface1].

Resultados

1
2
3
4
5
6
7
> php trait-08.php
AbstractClass::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
AbstractClass::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
AbstractClass::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

Ahora implementamos la solución 2 mediante el script [trait-09.php]. Consiste en sustituir la clase abstracta por un trait:

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

trait Trait1
{
    // atributos
    private int $attr1 = 11;
    private int $attr2 = 12;

    // getters y setters
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // método implementado
    #[\Override]
    public function doSomething(): void
    {
        print "Trait1::doSomething [$this->attr1,$this->attr2]\n";
    }
}

// clase 1
class Class1 implements Interface1
{
    // uso del trait
    use Trait1;

    // atributo
    private int $attr3 = 13;

    // getter y setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // implementación de doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// clase 2
class Class2 implements Interface1
{
    // uso del trait
    use Trait1;

    // atributo
    private int $attr4 = 14;

    // getter y setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // implementación de doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// función externa que usa la interfaz
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// pruebas
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// los setters "fluidos" pueden encadenarse
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

Comentarios

  • líneas 5–10: la interfaz [Interface1] no ha cambiado;
  • líneas 12–47: el trait [Trait1] sustituye a la clase abstracta [AbstractClass] de la solución 1. El código es el mismo, salvo por los siguientes detalles:
    • línea 12: el trait [Trait1] no implementa la interfaz [Interface1]. Esto es sintácticamente imposible;
    • líneas 15–16: la visibilidad de los atributos de la clase abstracta *[AbstractClass] cambia aquí de ***[protected] a [private]***. En ambos casos, el objetivo es dar a las clases concretas acceso directo a los atributos sin pasar por getters y setters. Con un trait, [private]* basta, ya que los atributos del trait pasan a ser los de la clase;
    • el trait [Trait1] no declara el método abstracto [doSomethingElse];
    • línea 42: a partir de PHP 8.3, el atributo [#[\Override]] puede aplicarse a un método de un trait. Esto se verifica en cada clase que usa el trait: aquí, el método [doSomething] debe corresponder a un método de una interfaz o de una clase padre de [Class1] y de [Class2]. Efectivamente es así: es el método [doSomething] de [Interface1];
  • línea 50: la clase *[Class1] de la solución 2 es idéntica a la clase *[Class1] de la solución 1, salvo por los siguientes detalles:
    • implementa la interfaz [Interface1], mientras que en la solución 1 extendía la clase abstracta [AbstractClass];
    • usa el trait [Trait1] (línea 53) para implementar parte de la interfaz;
  • línea 79: se aplican los mismos comentarios que para [Class1];
  • el resto del código permanece sin cambios.

Resultados

1
2
3
4
5
6
7
> php trait-09.php
Trait1::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
Trait1::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
Trait1::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

Efectivamente obtenemos los mismos resultados.

9.7. Los traits en PHP 8

PHP 8 ha hecho que los traits sean más confiables y completos. El script [trait-10.php] ilustra estas novedades:

<?php

declare(strict_types=1);

// un trait que exige algo a las clases que lo usan
trait CounterTrait
{
    // constante del trait (PHP 8.2)
    public const int STEP = 10;

    // atributo estático: cada clase que lo usa tiene el suyo
    private static int $nbInstances = 0;

    // atributo de instancia
    private int $counter = 0;

    // método estático del trait
    public static function getNbInstances(): int
    {
        return self::$nbInstances;
    }

    // método abstracto: la clase que lo usa debe definirlo (firma verificada desde PHP 8.0)
    abstract protected function getName(): string;

    // para ser llamado por el constructor de la clase que lo usa
    private function register(): void
    {
        self::$nbInstances++;
    }

    // método concreto que usa el método abstracto y la constante
    public function increment(): static
    {
        $this->counter += self::STEP;
        print "{$this->getName()}: counter=$this->counter\n";
        return $this;
    }
}

class Car
{
    use CounterTrait;

    public function __construct(private string $registration)
    {
        $this->register();
    }

    // implementación del método abstracto del trait
    #[\Override]
    protected function getName(): string
    {
        return "Car[$this->registration]";
    }
}

class Bike
{
    use CounterTrait;

    public function __construct()
    {
        $this->register();
    }

    #[\Override]
    protected function getName(): string
    {
        return "Bike";
    }
}

// pruebas
(new Car("AB-123-CD"))->increment()->increment();
new Car("EF-456-GH");
(new Bike())->increment();
// cada clase tiene su propio atributo estático
print "number of cars: " . Car::getNbInstances() . "\n";
print "number of bikes: " . Bike::getNbInstances() . "\n";
// la constante del trait es accesible a través de la clase, no a través del trait
print "step: " . Car::STEP . "\n";
try {
    print CounterTrait::STEP . "\n";
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}
// una clase que usa el trait debe implementar el método abstracto
// class Plane { use CounterTrait; }  // Fatal error: Class Plane contains 1 abstract method...

Comentarios

  • línea 9: desde PHP 8.2, un trait puede declarar constantes. Estas pasan a ser constantes de la clase que usa el trait;
  • línea 12: un trait puede declarar atributos estáticos. Al igual que los atributos de instancia, se copian en cada clase que usa el trait: cada clase tiene su propio contador de instancias;
  • líneas 18–21: un trait puede declarar métodos estáticos. En el código del trait, [self] se refiere a la clase que usa el trait;
  • línea 24: un trait puede declarar métodos abstractos. Toda clase que use el trait debe implementarlos; de lo contrario, debe declararse ella misma abstracta (véase la clase [Plane] comentada al final del script). A partir de PHP 8.0, se verifica la firma de la implementación (tipos de los parámetros y del retorno). Esta es la manera adecuada de imponer requisitos a las clases que usan el trait, en lugar de suponer que tienen un atributo o un método determinado;
  • líneas 33–38: un método concreto [increment] que usa el método abstracto [getName] y la constante [STEP]. Devuelve [$this] (tipo [static]) para que pueda encadenarse;
  • líneas 41–56: la clase [Car] usa el trait, llama en su constructor al método privado [register] del trait e implementa el método abstracto [getName]. Observe el atributo [#[\Override]] en esta implementación: se acepta porque la clase implementa un método abstracto del trait;
  • líneas 58–72: la clase *[Bike]* hace lo mismo;
  • líneas 79–80: cada clase tiene su propio atributo estático [$nbInstances];
  • línea 82: la constante del trait es accesible a través de la clase que lo usa;
  • línea 84: pero no directamente a través del trait: se produce un error.

Resultados

1
2
3
4
5
6
7
8
> php trait-10.php
Car[AB-123-CD]: counter=10
Car[AB-123-CD]: counter=20
Bike: counter=10
number of cars: 2
number of bikes: 1
step: 10
Error: Cannot access trait constant CounterTrait::STEP directly

9.8. Conclusión

De los ejemplos anteriores se desprende que los casos de uso en los que usar un trait aporta un beneficio neto no son evidentes. En nuestros ejemplos, siempre podemos prescindir de él sustituyéndolo por una clase. Sin embargo, es útil para factorizar código entre distintas clases, como si ese código perteneciera a una clase padre, sin consumir la herencia simple de la que dispone una clase PHP. Es lo que haremos en la versión 4 del ejercicio de aplicación.