## Kovarianz und Kontravarianz

Mit PHP 7.2.0 wurde teilweise Kontravarianz eingeführt, indem Typeneinschränkungen bei Parametern von Kindmethoden entfernt wurden. Mit PHP 7.4.0 wurde dann vollständige Unterstützung für Kovarianz und Kontravarianz eingeführt.

Kovarianz erlaubt es den Methoden eines Kindes, einen spezifischeren Typen als die Elternmethode für den Rückgabewert zurückzugeben. Die Kontravarianz erlaubt einen weniger spezifischen Parametertyp in einer Kindmethode als in der Elternmethode.

Eine Typdeklaration wird in den folgenden Fällen als spezifischer angesehen:

- Ein Typ wird aus einem Vereinigungstypen entfernt
- Ein Typ wird zu einem Schnittmengentypen hinzugefügt.
- Ein Klassentyp wird zu dem Typen eines seiner Kinder geändert
- iterable wird zu array oder Traversable geändert

Falls das Gegenteil zutrifft, wird ein Klassentyp als weniger spezifisch angesehen.

### Kovarianz

Um Kovarianz zu illustrieren, wird eine einfache abstrakte Elternklasse Tier erzeugt. Tier wird von seinen Kindern Katze und Hund beerbt.

`<?php
abstract class Tier
{
protected string $name;
public function __construct(string $name)
{
$this->name = $name;
}
abstract public function gibLaut();
}
class Hund extends Tier
{
public function gibLaut()
{
echo $this->name . " bellt";
}
}
class Katze extends Tier
{
public function gibLaut()
{
echo $this->name . " miaut";
}
}`

Beachtenswert ist, dass keine der Methoden hier einen Wert zurückgibt. Es werden nun ein paar Factories hinzugefügt, die ein neues Objekt der Klassen Tier, Katze oder Hund erzeugen.

`<?php
interface TierHeim
{
public function adoptiere(string $name): Tier;
}
class KatzenHeim implements TierHeim
{
public function adoptiere(string $name): Katze // statt den Klassentyp Tier zurückzugeben, kann hier Typ Katze verwendet werden
{
return new Katze($name);
}
}
class HundeHeim implements TierHeim
{
public function adoptiere(string $name): Hund // statt den Klassentyp Tier zurückzugeben, kann hier Typ Hund verwendet werden
{
return new Hund($name);
}
}
$kaetzchen = (new KatzenHeim)->adoptiere("Ricky");
$kaetzchen->gibLaut();
echo "\n";
$huendchen = (new HundeHeim)->adoptiere("Mavrick");
$huendchen->gibLaut();`

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

    Ricky miaut
    Mavrick bellt

### Kontravarianz

Um das vorherige Beispiel mit den Klassen Tier, Katze und Hund fortzusetzen, werden nun die Klassen Nahrung sowie Tierfutter definiert, sowie auch eine Methode iss(Tierfutter $futter) zur abstrakten Klasse Tier hinzugefügt.

`<?php
class Nahrung {}
class Tierfutter extends Nahrung {}
abstract class Tier
{
protected string $name;
public function __construct(string $name)
{
$this->name = $name;
}
public function iss(Tierfutter $futter)
{
echo $this->name . " isst " . get_class($futter);
}
}`

Um das Verhalten der Kontravarianz zu sehen, wird nun die Methode iss in der Klasse Hund überschrieben, um jedes Objekt der Klasse Nahrung zuzulassen. Die Klasse Katze bleibt unverändert.

`<?php
class Hund extends Tier
{
public function iss(Nahrung $futter) {
echo $this->name . " isst " . get_class($futter);
}
}`

Das folgende Beispiel zeigt das Verhalten der Kontravarianz.

`<?php
$kaetzchen = (new KatzenHeim)->adoptiere("Ricky");
$katzenFutter = new Tierfutter();
$kaetzchen->iss($katzenFutter);
echo "\n";
$huendchen = (new HundeHeim)->adoptiere("Mavrick");
$banane = new Nahrung();
$huendchen->iss($banane);`

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

    Ricky isst Tierfutter
    Mavrick isst Nahrung

Was geschieht nun aber, wenn man der iss()-Methode von $kaetzchen versucht die $banane zu übergeben?

`$kitty->iss($banane);`

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

    Fatal error: Uncaught TypeError: Argument 1 passed to Tier::iss() must be an instance of Tierfutter, instance of Nahrung given

### Varianz der Eigenschaften

Standardmäßig sind Eigenschaften weder kovariant noch kontravariant, d. h. sie sind invariant. Das bedeutet, dass sich ihr Typ in einer Kindklasse überhaupt nicht ändern darf. Der Grund dafür ist, dass "get"-Operationen kovariant und "set"-Operationen kontravariant sein müssen. Die einzige Möglichkeit für eine Eigenschaft, beide Anforderungen zu erfüllen, besteht darin, invariant zu sein.

Seit PHP 8.4.0 ist es mit der Einführung von abstrakten Eigenschaften (auf einer Schnittstelle oder einer abstrakten Klasse) und virtuellen Eigenschaften möglich, eine Eigenschaft zu deklarieren, die nur eine get- oder set-Operation hat. Folglich können abstrakte Eigenschaften oder virtuelle Eigenschaften, die nur eine "get"-Operation benötigen, kovariant sein. Ebenso kann eine abstrakte Eigenschaft oder eine virtuelle Eigenschaft, die nur eine "set"-Operation benötigt, kontravariant sein.

Sobald eine Eigenschaft jedoch sowohl eine get- als auch eine set-Operation hat, ist sie für weitere Erweiterungen nicht mehr kovariant oder kontravariant. Mit anderen Worten: Sie ist nun invariant.

Beispiel #1 Varianz des Eigenschaftstyps

`<?php
class Animal {}
class Dog extends Animal {}
class Poodle extends Dog {}
interface PetOwner
{
// Es wird nur eine get-Operation benötigt, so dass diese kovariant
// sein kann.
public Animal $pet { get; }
}
class DogOwner implements PetOwner
{
// Dies kann ein restriktiverer Typ sein, da die "get"-Seite immer ein
// Animal zurückgibt. Da es sich jedoch um eine native Eigenschaft handelt,
// können Kinder dieser Klasse den Typ nicht mehr ändern.
public Dog $pet;
}
class PoodleOwner extends DogOwner
{
// Dies ist NICHT ZULÄSSIG, da für DogOwner::$pet sowohl get- als auch
// set-Operationen definiert sind und benötigt werden.
public Poodle $pet;
}
?>`
`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open