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]:
9.2. Incluindo um trait em uma classe
O script [trait-01.php] demonstra um uso básico de um trait em uma classe:
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
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]:
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
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:
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
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:
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
Neste caso de uso, o trait [Trait01] pode ser facilmente substituído por uma classe. Isso é demonstrado pelo seguinte script [trait-05.php]:
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
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:
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
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:
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
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
Cque contém o código comum às classes derivadas. A classeCimplementa a interfaceI, mas certos métodos — que devem ser definidos nas classes derivadas — são declarados abstratos na classeC, 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]):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | |
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
Agora implementamos a solução 2 com o script [trait-09.php]. Trata-se de substituir a classe abstrata por um trait:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | |
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
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:
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
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.