9. Traits
Traits sind Strukturen, die Klassen ähneln. Sie können jedoch nicht instanziiert werden: Sie sind dazu bestimmt, in Klassen eingebunden zu werden. Das Einbinden eines Traits in eine Klasse hat dieselbe Wirkung, als wäre der Code des Traits in die Klasse kopiert worden. Code, der in mehreren Klassen wiederverwendet werden kann, wird in einem Trait abgelegt.
Traits gibt es seit PHP 5.4. PHP 8 hat mehrere Neuerungen eingeführt, die wir am Ende dieses Kapitels besprechen: die Signaturprüfung für abstrakte Methoden (PHP 8.0), Trait-Konstanten (PHP 8.2) und das Attribut [#[\Override]], das in einem Trait verwendet werden kann (PHP 8.3).
9.1. Die Verzeichnisstruktur der Skripte
Die Skripte dieses Kapitels befinden sich im Ordner [scripts-console/traits]:
9.2. Ein Trait in eine Klasse einbinden
Das Skript [trait-01.php] zeigt eine grundlegende Verwendung eines Traits in einer Klasse:
Code-Kommentare
- Zeilen 5–22: Definition der Klasse [Class04] mit einem Attribut [$name] (vom Konstruktor initialisiert), seinem Getter und seinem Setter;
- Zeilen 24–39: Wir nehmen den Code von [Class04] – ohne ihren Konstruktor – und verschieben ihn in den Trait [Trait04]. Diesmal wird das Attribut explizit zusammen mit seinem Typ deklariert. Den Konstruktor nehmen wir nicht auf, da ein Trait nicht instanziiert werden kann;
- Zeile 24: Das Schlüsselwort [trait] kennzeichnet [Trait04] als Trait und nicht als Klasse;
- Zeilen 41–51: Wir definieren eine Klasse [Class05] , die den Code des Traits [Trait04] einbindet und um einen Konstruktor ergänzt, damit die Klasse instanziierbar ist;
- Zeile 44: Das Schlüsselwort [use] erlaubt es, innerhalb einer Klasse einen Trait in diese Klasse einzubinden. Es darf nicht mit der Anweisung [use] verwechselt werden, die außerhalb jeder Klasse steht und einen Namen aus einem Namespace importiert;
- Zeilen 54–60: Tests zeigen, dass die Klassen [Class04] und [Class05] gleich funktionieren.
Ergebnisse
Die Ergebnisse in den Zeilen 4–11 zeigen, dass die Objekte [Class04] und [Class05] denselben Inhalt haben: Das private Attribut [$name] des Traits ist zu einem privaten Attribut der Klasse [Class05] geworden.
Fazit: Die Anweisung [use Trait] in einer Klasse ist gleichbedeutend damit, den Code von [Trait] in die Klasse einzufügen.
9.3. Denselben Trait in verschiedenen Klassen verwenden
Einer der Hauptvorteile eines Traits scheint die Wiederverwendung desselben Codes (Attribute + Methoden) in verschiedenen Klassen zu sein. Wir werden jedoch sehen, dass sich dasselbe Ziel auch mit einfachen Klassen erreichen lässt.
Die gemeinsame Nutzung eines Traits durch mehrere Klassen wird durch das folgende Skript veranschaulicht, [trait-02.php]:
Kommentare
- Zeilen 5–15: ein Trait, der ein Attribut [$id] und eine Methode [doSomething] definiert;
- Der Trait [Trait01] wird in zwei Klassen eingebunden: [Class02] (Zeilen 17–36) und [Class03] (Zeilen 38–53);
- Zeilen 20–24: Einbindung von [Trait01] in [Class02]. Auf die Einbindung folgt ein Block [{...}], mit dem sich die eingebundenen Methoden anpassen lassen;
- Zeile 23: Diese Zeile löst einen Konflikt auf: [Trait01] und [Class02] haben beide eine Methode namens [doSomething]. In diesem Fall hat die Methode der Klasse Vorrang: Die Methode des Traits wird verdeckt. Der Operator [as] macht die Methode [Trait01::doSomething] in der Klasse unter dem Namen [doSomethingInTrait] zugänglich. Innerhalb von [Class02] gelten somit die folgenden Schreibweisen:
- [doSomethingInTrait] um die Methode [Trait01::doSomething] aufzurufen;
- [doSomething] um die Methode [Class02::doSomething] aufzurufen;
- Zeilen 30–32: Die Klasse [Class02] verwendet das Attribut und die Methode von [Trait01] , als wären es ihre eigenen;
- Zeilen 38–53: Die Klasse [Class03] ist analog zur Klasse [Class02]. Die Einbindung von [Trait01] ist hier einfacher, da es keinen Konflikt zwischen den Methoden von [Trait01] und [Class03] gibt.
Ergebnisse
Beachten Sie, dass der Trait [Trait01] nicht zwischen den Klassen [Class02] und [Class03] geteilt wird. Das Attribut [$id] von [Trait01] wird durch die Einbindung von [Trait01] in die Klassen [Class02] und [Class03] zu zwei getrennten Attributen: [Class02::$id] und [Class03::$id]. Das zeigen die Zeilen 3 und 5 der Ergebnisse. Wäre das Attribut [$id] zwischen den Klassen [Class02] und [Class03] geteilt worden, wäre der Wert in Zeile 5 20 statt 10 gewesen.
Das Skript [trait-03.php] zeigt, dass sich dasselbe Ergebnis erzielen lässt, wenn man statt des Traits eine Klasse verwendet:
Kommentare
- Zeilen 6–28: Die Klasse [Class01] ersetzt den Trait [Trait01]. Der Code von [Trait01] wurde in den Code der Klassen [Class02] und [Class03] übernommen. Hier ist das nicht der Fall: Eine Referenz auf ein Objekt [Class01] wird in die Klassen [Class02] und [Class03] injiziert. Die Attribute der Klasse [Class01] liegen daher außerhalb der Objekte [Class02] und [Class03] . Da das Attribut [$id] privat ist, müssen ein Getter und ein Setter bereitgestellt werden. Das ist der erste Unterschied zu einem Trait: Man muss Code schreiben, um auf die privaten Attribute der Klasse zuzugreifen. Wir hätten das Attribut [$id] öffentlich machen können, das ist jedoch nicht empfehlenswert: Mit einem Setter lässt sich der Wert eines Attributs beim Setzen validieren;
- Zeile 33: Die Referenz auf das Objekt
*[Class01]wird dank Parameter-Promotion durch den Konstruktor in*[Class02]injiziert. Der PHP-7-Kurs verwendete einen Setter [setClass01]. Die Injektion über den Konstruktor ist vorzuziehen: Das Objekt [Class02] ist vollständig, sobald es konstruiert ist, und da das Attribut [readonly] ist, kann die Referenz nicht mehr geändert werden; - Zeilen 41–45: Bei jeder Verwendung des Codes [Class01] müssen wir über das Attribut [$this->class01] gehen;
- Zeilen 51–70: Die Klasse [Class03] ist ein Klon der Klasse [Class02], nur dass ihre Methode einen anderen Namen hat;
- Zeilen 73–81: der erste Test. Dabei werden zwei verschiedene Instanzen der Klasse [Class01] in die Objekte [Class02] und [Class03] injiziert;
- Zeilen 84–94: Der zweite Test injiziert dieselbe Instanz der Klasse [Class01] in die Objekte [Class02] und [Class03].
Ergebnisse
Kommentare zu den Ergebnissen
- Zeilen 3–6: Wir erhalten dieselben Ergebnisse wie mit dem Trait [Trait01]. Daraus lässt sich schließen, dass der Trait hier nicht unverzichtbar ist, den Codeumfang aber verringert, da keine Methoden für den Zugriff auf die Attribute des Traits nötig sind: Diese sind fester Bestandteil der Klasse, in die der Trait eingebunden wurde;
- Zeilen 8–11: Da dieselbe Referenz auf [Class01] in die Objekte [Class02] und [Class03] injiziert wurde, wurde das Attribut [Class01::$id] von beiden Objekten gemeinsam genutzt. Deshalb zeigt Zeile 10 der Ergebnisse bei Verwendung des Traits 20 statt 10 an. Daraus lässt sich schließen, dass der Trait nicht verwendet werden kann, wenn Attribute zwischen Objekten geteilt werden sollen; stattdessen muss eine Klasse eingesetzt werden.
9.4. Methoden in einem Trait bündeln
Im vorherigen Beispiel enthielt der Trait Attribute und Methoden. Hier betrachten wir den Fall, dass er nur Methoden enthält. Der Trait ähnelt dann einer Auslagerung von Methoden, die in verschiedenen Klassen verwendet werden können. Da der Trait hier keine Attribute hat, betrachten wir den Fall, dass seine Methoden ausschließlich mit den ihnen übergebenen Parametern arbeiten. Zwingend ist das nicht: Ein Trait kann mit einem Attribut [$this->attribute1] arbeiten, ohne dieses Attribut selbst zu besitzen. In diesem Fall ist es Sache der Klassen, die den Trait verwenden, das Attribut [$this->attribute1] bereitzustellen.
Hat der Trait nur Methoden, die ausschließlich mit den ihnen übergebenen Parametern arbeiten, zeigen wir, dass sich der Trait durch eine Klasse mit denselben, als static deklarierten Methoden ersetzen lässt.
Die Verwendung des Traits wird durch das Skript [trait-04.php] veranschaulicht, das den Trait des vorherigen Beispiels wiederverwendet, aber alle Attribute entfernt:
Kommentare
- Zeilen 5–12: Der Trait [Trait01] hat keine Attribute mehr;
- Zeilen 17–21: [Trait01] ist in [Class02] eingebunden. Die Methode von [Trait01] wird in Zeile 26 verwendet;
- Zeile 35: [Trait01] ist in [Class03] eingebunden. Die Methode von [Trait01] wird in Zeile 41 verwendet.
Ergebnisse
In diesem Anwendungsfall kann der Trait [Trait01] ohne Weiteres durch eine Klasse ersetzt werden. Das zeigt das folgende [trait-05.php]-Skript:
Kommentare
- Zeilen 6–18: Der Trait [Trait01] wird durch eine Klasse [Class01] ersetzt, deren Methoden alle statisch sind. Sie muss weder instanziiert noch abgeleitet werden. Im PHP-7-Kurs wurde sie als abstract deklariert, um ihre Instanziierung zu verhindern, wobei bedauert wurde, dass PHP das Präfix [final abstract] ablehnt. Das ist auch in PHP 8 noch so: Stattdessen deklarieren wir die Klasse als [final] (nicht ableitbar) mit einem privaten Konstruktor (nicht instanziierbar). So sind wir bei der Klasse [Utilities] in Version 3 der Übungsanwendung vorgegangen;
- Zeile 25: Statt [$this->doSomethingInTrait()] schreiben wir nun [Class01::doSomething()], das heißt, wir rufen die statische Methode [doSomething] der Klasse [Class01] auf;
- Zeile 37: Dasselbe Vorgehen wird in [Class03] wiederholt.
Ergebnisse
Wir erhalten tatsächlich dasselbe Ergebnis wie mit dem Trait [Trait01], was zeigt, dass sich seine Verwendung vermeiden lässt. Wir haben festgestellt, dass die Methoden eines Traits mit einem Attribut [$this->attribute1] arbeiten können, auch wenn der Trait dieses Attribut selbst nicht besitzt; es ist dann Sache der Klassen, die den Trait verwenden, es bereitzustellen. Das ist ein exotisches und fragiles Szenario: Besser ist es, das Attribut [$this->attribute1] in den Trait selbst „hochzuziehen“. So ist es zwangsläufig Teil der Attribute der Klasse, die den Trait verwendet. Am Ende des Kapitels sehen wir, dass PHP 8 eine saubere Lösung bietet, um von Klassen, die einen Trait verwenden, etwas zu verlangen: abstrakte Methoden.
9.5. Mehrfachvererbung mit einem Trait
In der Literatur liest man häufig, dass Traits Mehrfachvererbung erlauben: die Möglichkeit, dass eine Klasse von mehreren Klassen erbt. Die Sprache C++ unterstützt dieses Merkmal, Java und C# dagegen nicht, da sie nur Einfachvererbung kennen. Wir zeigen, dass die Verwendung eines Traits in einer abgeleiteten Klasse zwar tatsächlich etwas der Mehrfachvererbung Ähnliches ermöglicht, sich dieser Anwendungsfall aber auch mit einfachen Klassen umsetzen lässt.
Das Skript [trait-06.php] implementiert eine abgeleitete Klasse und einen Trait:
Kommentare
- Zeilen 5–18: ein Trait [Trait01] mit einem Attribut und einer Methode, die es bearbeitet;
- Zeilen 20–33: eine Klasse [Class02] , die nichts mit dem Trait [Trait01] zu tun hat. Sie verwendet ihn nicht;
- Zeile 23: Das einzige Attribut von [Class02] hat die Sichtbarkeit [protected] , damit es in abgeleiteten Klassen zugänglich ist;
- Zeile 36: Die Klasse [Class03] erweitert die Klasse [Class02]. Zusätzlich bindet sie den Trait [Trait01] ein (Zeile 39). Sie erbt also die Attribute und Methoden von [Class02] und übernimmt die Attribute und Methoden von [Trait01]. Das entspricht somit der Mehrfachvererbung.
Ergebnisse
Wie in einem früheren Beispiel zeigen wir, dass:
- der Trait durch eine Klasse ersetzt werden kann;
- wir, statt den Trait in die abgeleitete Klasse einzubinden, eine Referenz auf eine Instanz dieser Klasse in sie injizieren.
Das Skript [trait-07.php] lautet wie folgt:
Kommentare
- Zeilen 5–29: Die Klasse
*[Class01]ersetzt den Trait*[Trait01]. Da ein [Class01]-Objekt über eine Referenz verwendet wird, wurden für das Attribut [$i] ein Getter und ein Setter vorgesehen; - Zeilen 31–44: Die Klasse [Class02] bleibt unverändert;
- Zeile 46: Die Klasse [Class03] erweitert die Klasse [Class02];
- Zeile 49: Eine Referenz auf ein Objekt [Class01] wird über den Konstruktor in [Class03] injiziert;
- Zeilen 54–66: Die Methode [doSomethingInClass03] tut dasselbe wie zuvor, jedoch mit komplexerem Code.
Ergebnisse
Aus diesem Beispiel lässt sich erneut schließen, dass der Trait nicht unverzichtbar ist; man muss jedoch anerkennen, dass er kürzeren Code in der abgeleiteten Klasse ermöglicht.
9.6. Einen Trait statt einer abstrakten Klasse verwenden
Der folgende Anwendungsfall ist häufig: Sie erstellen eine recht allgemeine Schnittstelle I, die mehrere Implementierungen hervorbringen kann. Diese Implementierungen teilen sich gemeinsamen Code, unterscheiden sich aber in anderen Methoden. Es gibt zwei Möglichkeiten, diesen Anwendungsfall umzusetzen:
- Sie erstellen eine abstrakte Klasse
C, die den Code enthält, der den abgeleiteten Klassen gemeinsam ist. Die KlasseCimplementiert die SchnittstelleI, aber bestimmte Methoden – die in den abgeleiteten Klassen definiert werden müssen – werden in der KlasseCals abstrakt deklariert, die damit selbst abstrakt ist. Anschließend erstellen wir von C abgeleitete Klassen C1 und C2, die jeweils die abstrakten Methoden ihrer Elternklasse C auf ihre eigene Weise implementieren; - wir erstellen einen Trait T, der der abstrakten Klasse C der vorherigen Lösung fast gleicht. Dieser Trait implementiert die Schnittstelle I nicht, da das syntaktisch nicht möglich ist. Anschließend erstellen wir die Klassen C1 und C2, die die Schnittstelle I implementieren und den Trait T verwenden. Diesen Klassen bleibt nur noch, die Methoden der Schnittstelle I zu implementieren, die der von ihnen importierte Trait T nicht implementiert.
Hier ein Beispiel, das zeigt, wie ähnlich sich diese beiden Lösungen sind. Anwendung 1 setzt Lösung 1 um ([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 | |
Kommentare
- Zeilen 5–10: Die Schnittstelle [Interface1] hat zwei Methoden;
- Zeile 12: Die abstrakte Klasse [AbstractClass] implementiert die Schnittstelle [Interface1]. Sie hat zwei Attribute mit ihren Gettern und Settern, implementiert die Methode [doSomething] der Schnittstelle [Interface1] (Zeile 43), implementiert aber die Methode [doSomethingElse] nicht. Diese Methode wird daher als abstrakt deklariert (Zeile 50). Die abstrakte Klasse [AbstractClass] kann nicht instanziiert werden und muss, um nützlich zu sein, abgeleitet werden;
- Zeilen 29–39: Die Setter sind „fluent“: Statt nichts zurückzugeben, liefern sie das Objekt [$this] zurück. Das ermöglicht verkettete Aufrufe (Zeile 116). Der Rückgabetyp [static] (PHP 8.0) bezeichnet die Klasse des Objekts, auf dem die Methode aufgerufen wurde: [(new Class1())->setAttr1(21)] ist vom Typ [Class1] und nicht [AbstractClass], wodurch anschließend [setAttr3] – eine Methode, die für [Class1] spezifisch ist – aufgerufen werden kann;
- Zeile 54: Die Klasse [Class1] erweitert die abstrakte Klasse [AbstractClass] und implementiert damit die Schnittstelle [Interface1]. Sie liefert einen Rumpf für die Methode [doSomethingElse], den ihre Elternklasse nicht definiert hatte. Außerdem ergänzt sie die Attribute ihrer Elternklasse um ein weiteres;
- Zeile 80: Die Klasse [Class2] tut dasselbe mit einem anderen Attribut;
- Zeilen 106–110: Die Funktion [useInterfaceWith] erhält einen Typ [Interface1] als Parameter und ruft beide Methoden dieser Schnittstelle auf;
- Zeilen 113–116: Die Funktion [useInterfaceWith] wird mit einem Typ [Class1] und anschließend mit einem Typ [Class2] aufgerufen. Das ist korrekt, da beide Typen die Schnittstelle [Interface1] implementieren.
Ergebnisse
Nun setzen wir Lösung 2 mit dem Skript [trait-09.php] um. Dabei wird die abstrakte Klasse durch einen Trait ersetzt:
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 | |
Kommentare
- Zeilen 5–10: Die Schnittstelle [Interface1] hat sich nicht geändert;
- Zeilen 12–47: Der Trait [Trait1] ersetzt die abstrakte Klasse [AbstractClass] aus Lösung 1. Der Code ist bis auf die folgenden Details derselbe:
- Zeile 12: Der Trait [Trait1] implementiert die Schnittstelle [Interface1] nicht. Das ist syntaktisch unmöglich;
- Zeilen 15–16: Die Sichtbarkeit der Attribute der abstrakten Klasse
*[AbstractClass]ändert sich hier von***[protected]zu[private]***. In beiden Fällen soll erreicht werden, dass konkrete Klassen direkt auf die Attribute zugreifen können, ohne Getter und Setter zu verwenden. Bei einem Trait genügt [private]* , da die Attribute des Traits zu denen der Klasse werden; - Der Trait [Trait1] deklariert die abstrakte Methode [doSomethingElse] nicht;
- Zeile 42: Ab PHP 8.3 kann das Attribut [#[\Override]] auf eine Trait-Methode angewendet werden. Das wird in jeder Klasse geprüft, die den Trait verwendet: Hier muss die Methode [doSomething] einer Methode einer Schnittstelle oder einer Elternklasse von [Class1] und [Class2] entsprechen. Das ist tatsächlich der Fall: Es ist die Methode [doSomething] von [Interface1];
- Zeile 50: Die Klasse
*[Class1]in Lösung 2 ist bis auf die folgenden Details identisch mit der Klasse*[Class1]in Lösung 1:- Sie implementiert die Schnittstelle [Interface1], während sie in Lösung 1 die abstrakte Klasse [AbstractClass] erweiterte;
- sie verwendet den Trait [Trait1] (Zeile 53), um einen Teil der Schnittstelle zu implementieren;
- Zeile 79: Es gelten dieselben Anmerkungen wie für [Class1];
- der restliche Code bleibt unverändert.
Ergebnisse
Wir erhalten tatsächlich dieselben Ergebnisse.
9.7. Traits in PHP 8
PHP 8 hat Traits zuverlässiger und vollständiger gemacht. Das Skript [trait-10.php] veranschaulicht diese Neuerungen:
Kommentare
- Zeile 9: Seit PHP 8.2 kann ein Trait Konstanten deklarieren. Diese werden zu Konstanten der Klasse, die den Trait verwendet;
- Zeile 12: Ein Trait kann statische Attribute deklarieren. Wie Instanzattribute werden sie in jede Klasse kopiert, die den Trait verwendet: Jede Klasse hat ihren eigenen Instanzzähler;
- Zeilen 18–21: Ein Trait kann statische Methoden deklarieren. Im Code des Traits bezeichnet [self] die Klasse, die den Trait verwendet;
- Zeile 24: Ein Trait kann abstrakte Methoden deklarieren. Jede Klasse, die den Trait verwendet, muss sie implementieren; andernfalls muss sie selbst als abstrakt deklariert werden (siehe die am Ende des Skripts auskommentierte Klasse [Plane] ). Seit PHP 8.0 wird die Signatur der Implementierung (Parameter- und Rückgabetypen) überprüft. So stellt man ordnungsgemäß Anforderungen an die Klassen, die den Trait verwenden, statt vorauszusetzen, dass sie ein bestimmtes Attribut oder eine bestimmte Methode besitzen;
- Zeilen 33–38: Eine konkrete Methode [increment], die die abstrakte Methode [getName] und die Konstante [STEP] verwendet. Sie gibt [$this] (Typ [static]) zurück, damit sie verkettet werden kann;
- Zeilen 41–56: Die Klasse [Car] verwendet den Trait, ruft in ihrem Konstruktor die private Methode [register] des Traits auf und implementiert die abstrakte Methode [getName]. Beachten Sie das Attribut [#[\Override]] an dieser Implementierung: Es wird akzeptiert, weil die Klasse eine abstrakte Methode des Traits implementiert;
- Zeilen 58–72: Die Klasse
*[Bike]* tut dasselbe; - Zeilen 79–80: Jede Klasse hat ihr eigenes statisches Attribut [$nbInstances];
- Zeile 82: Die Konstante des Traits ist über die Klasse zugänglich, die ihn verwendet;
- Zeile 84: aber nicht direkt über den Trait: Es tritt ein Fehler auf.
Ergebnisse
9.8. Fazit
Aus den vorherigen Beispielen geht hervor, dass Anwendungsfälle, in denen die Verwendung eines Traits einen klaren Nutzen bringt, nicht offensichtlich sind. In unseren Beispielen können wir stets auf ihn verzichten, indem wir ihn durch eine Klasse ersetzen. Nützlich ist er jedoch, um Code über verschiedene Klassen hinweg auszulagern, als gehörte dieser Code zu einer Elternklasse, ohne die einzige Vererbung zu verbrauchen, die einer PHP-Klasse zur Verfügung steht. Genau das werden wir in Version 4 der Übungsanwendung tun.