Enumeration methods

Enumeratiemethoden

Enums (zowel Pure Enums als Backed Enums) kunnen methoden bevatten en kunnen interfaces implementeren. Als een Enum een interface implementeert, dan accepteert elke typecontrole voor die interface ook alle gevallen van die Enum.

<?php

interface Colorful
{
    public function color(): string;
}

enum Suit implements Colorful
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;

    // Voldoet aan het interfacecontract.
    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }

    // Geen onderdeel van een interface; dat is prima.
    public function shape(): string
    {
        return "Rectangle";
    }
}

function paint(Colorful $c)
{
   /* ... */
}

paint(Suit::Clubs);  // Werkt

print Suit::Diamonds->shape(); // print "Rectangle"
?>

In dit voorbeeld hebben alle vier instanties twee methoden, color() en shape(). Wat betreft aanroepende code en typecontroles gedragen ze zich precies hetzelfde als elke andere objectinstantie.

Op een Backed Enum gaat de interfaceverklaring na de declaratie van het backing type.

<?php

interface Colorful
{
    public function color(): string;
}

enum Suit: string implements Colorful
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';

    // Voldoet aan het interfacecontract.
    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }
}
?>

Binnen een methode is de $this variabele gedefinieerd en verwijst naar de Case-instantie.

Methoden kunnen willekeurig complex zijn, maar in de praktijk zullen ze meestal een statische waarde retourneren of matchen op $this om verschillende resultaten voor verschillende gevallen te bieden.

Merk op dat het in dit geval een betere datamodelpraktijk zou zijn om ook een Enum Type met waarden Red en Black te definiëren en dat in plaats daarvan te retourneren. Echter, dat zou dit voorbeeld compliceren.

De bovenstaande hiërarchie is logisch vergelijkbaar met de volgende klassenstructuur (hoewel dit niet de daadwerkelijke code is die draait):

<?php

interface Colorful
{
    public function color(): string;
}

final class Suit implements UnitEnum, Colorful
{
    public const Hearts = new self('Hearts');
    public const Diamonds = new self('Diamonds');
    public const Clubs = new self('Clubs');
    public const Spades = new self('Spades');

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

    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }

    public function shape(): string
    {
        return "Rectangle";
    }

    public static function cases(): array
    {
        // Illegale methode, omdat het handmatig definiëren van een cases() methode op een Enum niet is toegestaan.
        // Zie ook de sectie "Waardenlijst".
    }
}
?>

Methoden kunnen publiek, privé of beschermd zijn, hoewel in de praktijk privé en beschermd gelijkwaardig zijn, aangezien overerving niet is toegestaan.