Skip to content

9. Traits

Traits são estruturas análogas a classes. No entanto, elas não podem ser instanciadas: destinam-se a ser incluídas em classes. Incluir um trait em uma classe tem o mesmo efeito que se o código do trait tivesse sido copiado para a classe. O código que pode ser reutilizado em várias classes é colocado em um trait.

Os traits existem desde o PHP 5.4. O PHP 8 introduziu várias novidades, que discutiremos no final deste capítulo: verificação de assinatura para métodos abstratos (PHP 8.0), constantes em traits (PHP 8.2), o atributo [#[\Override]] utilizável em um trait (PHP 8.3).

9.1. Estrutura de diretórios dos scripts

Os scripts deste capítulo estão na pasta [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. Incluindo um trait em uma classe

O script [trait-01.php] demonstra um uso básico de um trait em uma classe:

<?php

declare(strict_types=1);

class Class04
{
    // construtor com promoção do atributo [name]
    public function __construct(private string $name)
    {
    }

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

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

trait Trait04
{
    // atributo
    private string $name;

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

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

class Class05
{
    // inclusão do trait
    use Trait04;

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

// teste --------------
$class04 = new Class04("Tim");
$class05 = new Class05("Burton");
print $class04->getName() . "\n";
print $class05->getName() . "\n";
// exibição dos dois objetos
print_r($class04);
print_r($class05);

Comentários sobre o código

  • linhas 5–22: definição da classe [Class04] com um atributo [$name] (inicializado pelo construtor), seu getter e seu setter;
  • linhas 24–39: pegamos o código de [Class04]—excluindo seu construtor—e o movemos para o trait [Trait04]. Desta vez, o atributo é declarado explicitamente, juntamente com seu tipo. Não incluímos o construtor, pois um trait não pode ser instanciado;
  • linha 24: a palavra-chave [trait] designa [Trait04] como um trait em vez de uma classe;
  • linhas 41–51: definimos uma classe [Class05] que inclui o código do trait [Trait04] e lhe acrescenta um construtor, para tornar a classe instanciável;
  • Linha 44: a palavra-chave [use], colocada dentro de uma classe, permite incluir um trait na classe. Ela não deve ser confundida com a instrução [use], que é colocada fora de qualquer classe e importa um nome de um namespace;
  • Linhas 54–60: os testes mostram que as classes [Class04] e [Class05] funcionam da mesma maneira.

Resultados

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

Os resultados das linhas 4–11 mostram que os objetos [Class04] e [Class05] têm o mesmo conteúdo: o atributo privado [$name] do trait se tornou um atributo privado da classe [Class05].

Conclusão: usar a instrução [use Trait] em uma classe equivale a incluir na classe o código de [Trait] .

9.3. Usando o mesmo trait em classes diferentes

Um dos principais benefícios de um trait parece ser a reutilização do mesmo código (atributos + métodos) em diferentes classes. No entanto, veremos que o mesmo objetivo pode ser alcançado com classes simples.

O compartilhamento de um trait entre classes é ilustrado pelo seguinte script, [trait-02.php]:

<?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
{
    // inclusão de Trait01
    use Trait01 {
        // o método [Trait01::doSomething] é acessível
        // na classe com o nome [doSomethingInTrait]
        Trait01::doSomething as doSomethingInTrait;
    }

    // método específico da classe
    public function doSomething(): void
    {
        // atributo id
        $this->id += 10;
        // uso do método de Trait01
        $this->doSomethingInTrait();
        // exibição local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // inclusão de Trait01
    use Trait01;

    // método local da classe
    public function doSomethingElse(): void
    {
        // atributo id
        $this->id += 10;
        // uso do método de Trait01
        $this->doSomething();
        // exibição local
        print "Class03->doSomethingElse\n";
    }
}

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

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

Comentários

  • linhas 5–15: um trait que define um atributo [$id] e um método [doSomething];
  • o trait [Trait01] é incluído em duas classes: [Class02] (linhas 17–36) e [Class03] (linhas 38–53);
  • linhas 20–24: inclusão de [Trait01] em [Class02]. A inclusão é seguida por um bloco [{...}] que permite ajustar os métodos incluídos;
  • linha 23: essa linha resolve um conflito: [Trait01] e [Class02] possuem ambas um método chamado [doSomething]. Nesse caso, o método da classe tem precedência: o método do trait fica oculto. O operador [as] torna o método [Trait01::doSomething] acessível na classe com o nome [doSomethingInTrait]. Assim, dentro de [Class02], usaremos as seguintes notações:
    • [doSomethingInTrait] para chamar o método [Trait01::doSomething];
    • [doSomething] para chamar o método [Class02::doSomething];
  • Linhas 30–32: a classe [Class02] usa o atributo e o método de [Trait01] como se fossem seus;
  • linhas 38–53: a classe [Class03] é análoga à classe [Class02]. A inclusão de [Trait01] é mais simples aqui porque não há conflito entre os métodos de [Trait01] e 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 o trait [Trait01] não é compartilhado entre as classes [Class02] e [Class03]. O atributo [$id] de [Trait01] se torna, devido à inclusão de [Trait01] nas classes [Class02] e [Class03], dois atributos distintos: [Class02::$id] e [Class03::$id]. Isso é mostrado nas linhas 3 e 5 dos resultados. Se o atributo [$id] tivesse sido compartilhado entre as classes [Class02] e [Class03], o valor da linha 5 teria sido 20 em vez de 10.

O script [trait-03.php] mostra que o mesmo resultado pode ser obtido usando uma classe no lugar do trait:

<?php

declare(strict_types=1);

// classe que substitui o 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
{
    // uma referência a uma instância de Class01, injetada pelo construtor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método específico da classe
    public function doSomething(): void
    {
        // modificação do atributo de Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // uso do método de Class01
        $this->class01->doSomething();
        // exibição local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // uma referência a uma instância de Class01, injetada pelo construtor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método local da classe
    public function doSomethingElse(): void
    {
        // modificação do atributo de Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // uso do método de Class01
        $this->class01->doSomething();
        // exibição local
        print "Class03->doSomethingElse\n";
    }
}

// test01 ----------------
function test01(): void
{
    // dois objetos que acessarão duas instâncias diferentes de [Class01]
    $class02 = new Class02(new Class01());
    $class03 = new Class03(new Class01());
    // verificação
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test02 ----------------
function test02(): void
{
    // instância compartilhada de [Class01]
    $class01 = new Class01();
    // dois objetos que acessarão a mesma instância de [Class01]
    $class02 = new Class02($class01);
    $class03 = new Class03($class01);
    // verificação
    $class02->doSomething();
    $class03->doSomethingElse();
}

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

Comentários

  • Linhas 6–28: a classe [Class01] substitui o trait [Trait01]. O código de [Trait01] foi incorporado ao código das classes [Class02] e [Class03]. Aqui, não será assim: uma referência a um objeto [Class01] será injetada nas classes [Class02] e [Class03] . Os atributos da classe [Class01] serão, portanto, externos aos objetos [Class02] e [Class03] . Como o atributo [$id] é privado, é preciso fornecer um getter e um setter. Essa é a primeira diferença em relação a um trait: é preciso criar código para acessar os atributos privados da classe. Poderíamos ter tornado o atributo [$id] público, mas isso não é recomendado: usar um setter para definir o valor de um atributo permite validá-lo;
  • Linha 33: a referência ao objeto *[Class01] é injetada em *[Class02] por seu construtor, graças à promoção de parâmetros. O curso de PHP 7 usava um setter [setClass01]. A injeção pelo construtor é preferível: o objeto [Class02] está completo assim que é construído e, como o atributo é [readonly], a referência não pode mais ser alterada;
  • linhas 41–45: para qualquer uso do código de [Class01], precisamos passar pelo atributo [$this->class01];
  • linhas 51–70: a classe [Class03] é um clone da classe [Class02], exceto que seu método tem um nome diferente;
  • linhas 73–81: o primeiro teste. Consiste em injetar duas instâncias diferentes da classe [Class01] nos objetos [Class02] e [Class03];
  • linhas 84–94: o segundo teste injeta a mesma instância da classe [Class01] nos objetos [Class02] e [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

Comentários sobre os resultados

  • linhas 3–6: obtemos os mesmos resultados que com o trait [Trait01]. Podemos concluir que usar o trait não é essencial aqui, mas ele reduz a quantidade de código, pois não são necessários métodos para acessar os atributos do trait: eles fazem parte integrante da classe na qual o trait foi incorporado;
  • Linhas 8–11: como a mesma referência a [Class01] foi injetada nos objetos [Class02] e [Class03], o atributo [Class01::$id] foi compartilhado entre os dois objetos. É por isso que a linha 10 dos resultados exibe 20 em vez de 10 quando se usa o trait. Podemos concluir que, se atributos precisam ser compartilhados entre objetos, o trait não pode ser usado, e é preciso usar uma classe.

9.4. Agrupando métodos em um trait

No exemplo anterior, o trait continha atributos e métodos. Aqui, vamos considerar o caso em que ele contém apenas métodos. O trait passa então a ser uma fatoração de métodos que podem ser usados em classes diferentes. Como o trait aqui não tem atributos, vamos considerar o caso em que os métodos que ele contém operam exclusivamente sobre os parâmetros recebidos. Isso não é obrigatório: um trait pode operar sobre um atributo [$this->attribute1] sem possuir esse atributo. Nesse caso, cabe às classes que usam o trait fornecer o atributo [$this->attribute1].

No caso em que o trait tem apenas métodos que operam exclusivamente sobre os parâmetros recebidos, mostraremos que o trait pode ser substituído por uma classe com os mesmos métodos do trait, declarados como estáticos.

O uso do trait é ilustrado pelo script [trait-04.php], que reutiliza o trait do exemplo anterior, mas remove todos os atributos:

<?php

declare(strict_types=1);

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

class Class02
{
    // inclusão de Trait01
    use Trait01 {
        // o método [Trait01::doSomething] é acessível
        // na classe com o nome [doSomethingInTrait]
        Trait01::doSomething as doSomethingInTrait;
    }

    public function doSomething(): void
    {
        // chamada do método de Trait01
        $this->doSomethingInTrait();
        // exibição local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // inclusão de Trait01
    use Trait01;

    // método local da classe
    public function doSomethingElse(): void
    {
        // chamada do método de Trait01
        $this->doSomething();
        // exibição local
        print "Class03->doSomethingElse\n";
    }
}

// teste ----------------
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

Comentários

  • linhas 5–12: o trait [Trait01] não tem mais nenhum atributo;
  • linhas 17–21: [Trait01] é incluído em [Class02]. O método de [Trait01] é usado na linha 26;
  • linha 35: [Trait01] é incluído em [Class03]. O método de [Trait01] é usado na linha 41.

Resultados

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

Neste caso de uso, o trait [Trait01] pode ser facilmente substituído por uma classe. Isso é demonstrado pelo seguinte script [trait-05.php]:

<?php

declare(strict_types=1);

// classe nem instanciável nem derivável, contendo apenas métodos estáticos
final class Class01
{
    // construtor privado: nenhuma instanciação possível fora da classe
    private function __construct()
    {
    }

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

class Class02
{
    public function doSomething(): void
    {
        // chamada do método estático de Class01
        Class01::doSomething();
        // exibição local
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // método local da classe
    public function doSomethingElse(): void
    {
        // chamada do método estático de Class01
        Class01::doSomething();
        // exibição local
        print "Class03->doSomethingElse\n";
    }
}

// teste ----------------
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

Comentários

  • Linhas 6–18: o trait [Trait01] é substituído por uma classe [Class01], cujos métodos são todos estáticos. Não há necessidade de instanciá-la nem de derivá-la. O curso de PHP 7 a declarava abstrata para impedir sua instanciação, lamentando que o PHP rejeite o prefixo [final abstract]. Isso continua valendo no PHP 8: em vez disso, declaramos a classe [final] (não derivável) com um construtor privado (não instanciável). Foi o que fizemos com a classe [Utilities] na versão 3 do exercício de aplicação;
  • linha 25: em vez de escrever [$this->doSomethingInTrait()], escrevemos agora [Class01::doSomething()], ou seja, chamamos o método estático [doSomething] da classe [Class01];
  • linha 37: repete-se o mesmo procedimento em [Class03].

Resultados

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

De fato, obtemos o mesmo resultado que com o trait [Trait01], o que mostra que seu uso pode ser evitado. Observamos que os métodos de um trait podem operar sobre um atributo [$this->attribute1] mesmo que o próprio trait não tenha esse atributo; cabe às classes que usam o trait fornecê-lo. Trata-se de um cenário exótico e frágil: é melhor “subir” o atributo [$this->attribute1] para o próprio trait. Dessa forma, ele fará necessariamente parte dos atributos da classe que usa o trait. Veremos no final do capítulo que o PHP 8 oferece uma solução limpa para exigir algo das classes que usam um trait: os métodos abstratos.

9.5. Herança múltipla com um trait

É comum ler na literatura que os traits permitem a herança múltipla: a capacidade de uma classe herdar de várias classes. A linguagem C++ oferece esse recurso, mas nem Java nem C# o oferecem, pois suportam apenas herança simples. Mostraremos que, embora o uso de um trait em uma classe derivada permita de fato implementar algo semelhante à herança múltipla, esse caso de uso também pode ser implementado com classes simples.

O script [trait-06.php] implementa uma classe derivada e um trait:

<?php

declare(strict_types=1);

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

    // método a ser compartilhado
    public function doSomethingInTrait01(): void
    {
        // modificação de Trait01::$i
        $this->i++;
        // exibição
        print "Trait01::doSomethingInTrait01... i=$this->i\n";
    }
}

class Class02
{
    // atributo acessível às classes derivadas
    protected int $j = 0;

    // método
    public function doSomethingInClass02(): void
    {
        // modificação de Class02::$j
        $this->j += 10;
        // exibição
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

// classe derivada
class Class03 extends Class02
{
    // herda Class02::$j e inclui Trait01::$i
    use Trait01;

    // método
    public function doSomethingInClass03(): void
    {
        // uso do método de Trait01
        $this->doSomethingInTrait01();
        // modificação de Trait01::$i
        $this->i += 100;
        // modificação de Class03::$j (==Class02::$j)
        $this->j += 1000;
        // exibição
        print "Class03->doSomethingInClass03... i=$this->i, j=$this->j\n";
    }
}

// teste ----------------
(new Class02())->doSomethingInClass02();
(new Class03())->doSomethingInClass03();

Comentários

  • linhas 5–18: um trait [Trait01] com um atributo e um método que o manipula;
  • linhas 20–33: uma classe [Class02] que não tem nada a ver com o trait [Trait01]. Ela não o utiliza;
  • linha 23: o único atributo de [Class02] tem a visibilidade [protected] para que seja acessível nas classes derivadas;
  • Linha 36: a classe [Class03] estende a classe [Class02]. Além disso, ela incorpora o trait [Trait01] (linha 39). Por fim, ela herda os atributos e métodos de [Class02] e incorpora os atributos e métodos de [Trait01]. Isso é, portanto, análogo à herança múltipla.

Resultados

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

Assim como em um exemplo anterior, mostraremos que:

  • o trait pode ser substituído por uma classe;
  • em vez de incorporar o trait na classe derivada, injetamos nela uma referência a uma instância dessa classe.

O script [trait-07.php] é o seguinte:

<?php

declare(strict_types=1);

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

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

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

    // método
    public function doSomethingInClass01(): void
    {
        // modificação de Class01::$i
        $this->i++;
        // exibição
        print "Class01->doSomethingInClass01... i=$this->i\n";
    }
}

class Class02
{
    // atributo acessível às classes derivadas
    protected int $j = 0;

    // método específico da classe
    public function doSomethingInClass02(): void
    {
        // modificação de Class02::$j
        $this->j += 10;
        // exibição
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

class Class03 extends Class02
{
    // uma referência a uma instância de Class01, injetada pelo construtor
    public function __construct(private readonly Class01 $class01)
    {
    }

    // método local da classe
    public function doSomethingInClass03(): void
    {
        // uso do método de Class01
        $this->class01->doSomethingInClass01();
        // modificação de Class01::$i
        $i = $this->class01->getI();
        $i += 100;
        $this->class01->setI($i);
        // modificação de Class03::$j
        $this->j += 1000;
        // exibição
        print "Class03->doSomethingInClass03... i=$i, j=$this->j\n";
    }
}

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

Comentários

  • Linhas 5–29: a classe *[Class01] substitui o trait *[Trait01]. Como um objeto [Class01] será usado por meio de uma referência, foram fornecidos um getter e um setter para o atributo [$i];
  • linhas 31–44: a classe [Class02] permanece inalterada;
  • linha 46: a classe [Class03] estende a classe [Class02];
  • linha 49: uma referência a um objeto [Class01] é injetada em [Class03] por seu construtor;
  • Linhas 54–66: o método [doSomethingInClass03] faz o mesmo que antes, mas com um código mais complexo.

Resultados

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

Desse exemplo, podemos concluir que, mais uma vez, o trait não é essencial, mas é preciso reconhecer que ele permite um código mais curto na classe derivada.

9.6. Usando um trait em vez de uma classe abstrata

O caso de uso a seguir é comum: cria-se uma interface I bastante geral, que pode dar origem a várias implementações. Essas implementações compartilham código comum, mas diferem em outros métodos. Há duas maneiras de implementar esse caso de uso:

  • Cria-se uma classe abstrata C que contém o código comum às classes derivadas. A classe C implementa a interface I, mas certos métodos — que devem ser definidos nas classes derivadas — são declarados abstratos na classe C, que portanto é ela própria abstrata. Criam-se então as classes C1 e C2 derivadas de C, cada uma implementando à sua maneira os métodos abstratos de sua classe-mãe C;
  • cria-se um trait T quase idêntico à classe abstrata C da solução anterior. Esse trait não implementa a interface I porque, sintaticamente, não pode. Criam-se então as classes C1 e C2, que implementam a interface I e usam o trait T. Resta a essas classes apenas implementar os métodos da interface I que não são implementados pelo trait T que elas importam.

Eis um exemplo que ilustra o quanto essas duas soluções são parecidas. A aplicação 1 implementa a solução 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 acessíveis às classes derivadas
    protected int $attr1 = 11;
    protected int $attr2 = 12;

    // getters e 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 não implementado
    #[\Override]
    abstract public function doSomethingElse(): void;
}

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

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

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

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

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

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

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

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

// função externa
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// testes
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// setters "fluentes" podem ser encadeados
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

Comentários

  • linhas 5–10: a interface [Interface1] tem dois métodos;
  • linha 12: a classe abstrata [AbstractClass] implementa a interface [Interface1]. Ela tem dois atributos com seus getters e setters, implementa o método [doSomething] da interface [Interface1] (linha 43), mas não implementa o método [doSomethingElse]. Esse método é, portanto, declarado abstrato (linha 50). A classe abstrata [AbstractClass] não pode ser instanciada e, para ser útil, precisa ser derivada;
  • Linhas 29–39: os setters são “fluentes”: em vez de não retornar nada, eles retornam o objeto [$this]. Isso permite chamadas encadeadas (linha 116). O tipo de retorno [static] (PHP 8.0) refere-se à classe do objeto sobre o qual o método foi chamado: [(new Class1())->setAttr1(21)] é do tipo [Class1] e não [AbstractClass], o que permite chamar em seguida [setAttr3]— um método específico de [Class1];
  • Linha 54: a classe [Class1] estende a classe abstrata [AbstractClass] e, portanto, implementa a interface [Interface1]. Ela fornece um corpo para o método [doSomethingElse], que sua classe-mãe não havia definido. Ela também acrescenta um atributo aos de sua classe-mãe;
  • Linha 80: a classe [Class2] faz o mesmo com outro atributo;
  • linhas 106–110: a função [useInterfaceWith] recebe como parâmetro um tipo [Interface1] e chama os dois métodos dessa interface;
  • Linhas 113–116: a função [useInterfaceWith] é chamada com um tipo [Class1] e depois com um tipo [Class2]. Isso é correto porque ambos os tipos implementam a interface [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]

Agora implementamos a solução 2 com o script [trait-09.php]. Trata-se de substituir a classe abstrata por um 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 e 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";
    }
}

// classe 1
class Class1 implements Interface1
{
    // uso do trait
    use Trait1;

    // atributo
    private int $attr3 = 13;

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

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

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

// classe 2
class Class2 implements Interface1
{
    // uso do trait
    use Trait1;

    // atributo
    private int $attr4 = 14;

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

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

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

// função externa que usa a interface
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// testes
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// setters "fluentes" podem ser encadeados
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

Comentários

  • linhas 5–10: a interface [Interface1] não mudou;
  • linhas 12–47: o trait [Trait1] substitui a classe abstrata [AbstractClass] da solução 1. O código é o mesmo, exceto pelos seguintes detalhes:
    • linha 12: o trait [Trait1] não implementa a interface [Interface1]. Isso é sintaticamente impossível;
    • linhas 15–16: a visibilidade dos atributos da classe abstrata *[AbstractClass] muda aqui de ***[protected] para [private]***. Em ambos os casos, o objetivo é dar às classes concretas acesso direto aos atributos sem passar por getters e setters. Com um trait, [private]* basta, já que os atributos do trait se tornam os da classe;
    • o trait [Trait1] não declara o método abstrato [doSomethingElse];
    • Linha 42: a partir do PHP 8.3, o atributo [#[\Override]] pode ser aplicado a um método de trait. Isso é verificado em cada classe que usa o trait: aqui, o método [doSomething] deve corresponder a um método de uma interface ou de uma classe-mãe de [Class1] e de [Class2]. É exatamente o que acontece: trata-se do método [doSomething] de [Interface1];
  • Linha 50: a classe *[Class1] da solução 2 é idêntica à classe *[Class1] da solução 1, exceto pelos seguintes detalhes:
    • ela implementa a interface [Interface1], enquanto na solução 1 estendia a classe abstrata [AbstractClass];
    • ela usa o trait [Trait1] (linha 53) para implementar parte da interface;
  • Linha 79: valem os mesmos comentários feitos para [Class1];
  • o restante do código permanece inalterado.

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]

De fato, obtemos os mesmos resultados.

9.7. Traits no PHP 8

O PHP 8 tornou os traits mais confiáveis e completos. O script [trait-10.php] ilustra esses novos recursos:

<?php

declare(strict_types=1);

// um trait que exige algo das classes que o usam
trait CounterTrait
{
    // constante de trait (PHP 8.2)
    public const int STEP = 10;

    // atributo estático: cada classe que o usa tem o seu
    private static int $nbInstances = 0;

    // atributo de instância
    private int $counter = 0;

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

    // método abstrato: a classe que o usa deve defini-lo (assinatura verificada desde o PHP 8.0)
    abstract protected function getName(): string;

    // a ser chamado pelo construtor da classe que usa o trait
    private function register(): void
    {
        self::$nbInstances++;
    }

    // método concreto que usa o método abstrato e a 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();
    }

    // implementação do método abstrato do 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";
    }
}

// testes
(new Car("AB-123-CD"))->increment()->increment();
new Car("EF-456-GH");
(new Bike())->increment();
// cada classe tem seu próprio atributo estático
print "number of cars: " . Car::getNbInstances() . "\n";
print "number of bikes: " . Bike::getNbInstances() . "\n";
// a constante do trait é acessível pela classe, não pelo trait
print "step: " . Car::STEP . "\n";
try {
    print CounterTrait::STEP . "\n";
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}
// uma classe que usa o trait deve implementar o método abstrato
// class Plane { use CounterTrait; }  // Fatal error: Class Plane contains 1 abstract method...

Comentários

  • linha 9: desde o PHP 8.2, um trait pode declarar constantes. Elas se tornam constantes da classe que usa o trait;
  • linha 12: um trait pode declarar atributos estáticos. Assim como os atributos de instância, eles são copiados para cada classe que usa o trait: cada classe tem seu próprio contador de instâncias;
  • Linhas 18–21: um trait pode declarar métodos estáticos. No código do trait, [self] refere-se à classe que usa o trait;
  • Linha 24: um trait pode declarar métodos abstratos. Toda classe que usa o trait deve implementá-los; caso contrário, ela própria deve ser declarada abstrata (veja a classe [Plane] comentada no final do script). A partir do PHP 8.0, a assinatura da implementação (tipos dos parâmetros e do retorno) é verificada. Essa é a maneira correta de impor requisitos às classes que usam o trait, em vez de supor que elas tenham um determinado atributo ou método;
  • Linhas 33–38: um método concreto [increment] que usa o método abstrato [getName] e a constante [STEP]. Ele retorna [$this] (tipo [static]) para que possa ser encadeado;
  • Linhas 41–56: a classe [Car] usa o trait, chama em seu construtor o método privado [register] do trait e implementa o método abstrato [getName]. Observe o atributo [#[\Override]] nessa implementação: ele é aceito porque a classe implementa um método abstrato do trait;
  • linhas 58–72: a classe *[Bike]* faz o mesmo;
  • linhas 79–80: cada classe tem seu próprio atributo estático [$nbInstances];
  • linha 82: a constante do trait é acessível por meio da classe que o usa;
  • linha 84: mas não diretamente por meio do trait: ocorre um erro.

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. Conclusão

Pelos exemplos anteriores, fica claro que os casos de uso em que o trait traz um benefício líquido não são evidentes. Em nossos exemplos, sempre podemos dispensá-lo substituindo-o por uma classe. No entanto, ele é útil para fatorar código entre classes diferentes, como se esse código pertencesse a uma classe-mãe, sem consumir a herança simples de que dispõe uma classe PHP. É o que faremos na versão 4 do exercício de aplicação.