Métodos de enumerações

Enumerações (tanto Puras quanto Apoiadas) podem conter métodos e podem implementar interfaces. Se uma enumeração implementa uma interface, qualquer verificação de tipo para aquela interface também aceitará todos os casos daquela enumeração.

<?php

interface Colorido
{
    public function cor(): string;
}

enum Naipe implements Colorido
{
    case Copas;
    case Ouros;
    case Paus;
    case Espadas;

    // Cumpre o contrato da interface.
    public function cor(): string
    {
        return match($this) {
            Naipe::Copas, Naipe::Ouros => 'Vermelho',
            Naipe::Paus, Naipe::Espadas => 'Preto',
        };
    }

    // Não faz parte de uma interface; tudo bem.
    public function forma(): string
    {
        return "Retângulo";
    }
}

function pintar(Colorido $c)
{
   /* ... */
}

pintar(Naipe::Paus);  // Funciona

print Naipe::Ouros->shape(); // imprime "Retângulo"
?>

Nesse exemplo, todas as quatro instâncias de Naipe possuem dois métodos, cor() e forma(). Até onde o código chamador e as checagens de tipo sabem, elas se comportam exatamente da mesma forma que qualquer outra instância de objeto.

Em uma Enumeração Apoiada, a declaração de interface vai após a declaração do tipo de lastro.

<?php

interface Colorido
{
    public function cor(): string;
}

enum Naipe: string implements Colorido
{
    case Copas = 'C';
    case Ouros = 'O';
    case Paus = 'P';
    case Espadas = 'E';

    // Cumpre o contrato da interface.
    public function cor(): string
    {
        return match($this) {
            Naipe::Copas, Naipe::Ouros => 'Vermelho',
            Naipe::Paus, Naipe::Espadas => 'Preto',
        };
    }
}
?>

Dentro de um método, a variável $this é definida e se refere à instância do Caso.

Métodos podem ser arbitrariamente complexos, mas na prática geralmente retornam um valor estático ou match no $this para fornecer resultados diferentes para casos diferentes.

Note que nesse caso, uma prática melhor de modelagem de dados seria definir também um Tipo 'enum' CorDeNaipe com valores Preto e Vermelho e retornar isso no seu lugar. No entanto, isso complicaria esse exemplo.

A hierarquia acima é logicamente similar a seguinte estrutura de classes (embora esse não seja o código real que é executado):

<?php

interface Colorido
{
    public function cor(): string;
}

final class Naipe implements UnitEnum, Colorido
{
    public const Copas = new self('Copas');
    public const Ouros = new self('Ouros');
    public const Paus = new self('Paus');
    public const Espadas = new self('Espadas');

    private function __construct(public readonly string $nome) {}

    public function cor(): string
    {
        return match($this) {
            Naipe::Copas, Naipe::Ouros => 'Vermelho',
            Naipe::Paus, Naipe::Espadas => 'Preto',
        };
    }

    public function forma(): string
    {
        return "Retângulo";
    }

    public static function cases(): array
    {
        // Método ilegal, porque definir manualmente um método cases() em uma enumeração não é permitido.
        // Veja também a seção "Listagem de valores".
    }
}
?>

Métodos podem ser públicos, privados ou protegidos, apesar dos privados e protegidos serem equivalentes na prática, pois herança não é permitida.