Skip to content

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]:

1
2
3
4
5
6
php8-oct-2026/scripts-console/traits
├── trait-01.php
├── trait-02.php
├── ...
├── trait-09.php
└── trait-10.php

9.2. Ein Trait in eine Klasse einbinden

Das Skript [trait-01.php] zeigt eine grundlegende Verwendung eines Traits in einer Klasse:

<?php

declare(strict_types=1);

class Class04
{
    // Konstruktor mit Promotion des Attributs [name]
    public function __construct(private string $name)
    {
    }

    // Getter und Setter
    public function getName(): string
    {
        return $this->name;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

trait Trait04
{
    // Attribut
    private string $name;

    // Getter und Setter
    public function getName(): string
    {
        return $this->name;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

class Class05
{
    // Einbindung des Traits
    use Trait04;

    // Konstruktor
    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

// Test --------------
$class04 = new Class04("Tim");
$class05 = new Class05("Burton");
print $class04->getName() . "\n";
print $class05->getName() . "\n";
// Anzeige der beiden Objekte
print_r($class04);
print_r($class05);

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

> php trait-01.php
Tim
Burton
Class04 Object
(
    [name:Class04:private] => Tim
)
Class05 Object
(
    [name:Class05:private] => Burton
)

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]:

<?php

declare(strict_types=1);

trait Trait01
{
    // Attribut
    private int $id = 0;

    // Methode
    public function doSomething(): void
    {
        print "Trait01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // Einbindung von Trait01
    use Trait01 {
        // die Methode [Trait01::doSomething] ist in der Klasse
        // unter dem Namen [doSomethingInTrait] zugänglich
        Trait01::doSomething as doSomethingInTrait;
    }

    // klassenspezifische Methode
    public function doSomething(): void
    {
        // Attribut id
        $this->id += 10;
        // Verwendung der Methode von Trait01
        $this->doSomethingInTrait();
        // lokale Anzeige
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // Einbindung von Trait01
    use Trait01;

    // lokale Methode der Klasse
    public function doSomethingElse(): void
    {
        // Attribut id
        $this->id += 10;
        // Verwendung der Methode von Trait01
        $this->doSomething();
        // lokale Anzeige
        print "Class03->doSomethingElse\n";
    }
}

// test01 ----------------
function test01(): void
{
    $class02 = new Class02();
    $class03 = new Class03();
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();

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

1
2
3
4
5
6
> php trait-02.php
test01-----------------
Trait01::doSomething... (10)
Class02->doSomething
Trait01::doSomething... (10)
Class03->doSomethingElse

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:

<?php

declare(strict_types=1);

// Klasse, die den Trait ersetzt
class Class01
{
    // Attribut
    private int $id = 0;

    // Setter
    public function setId(int $id): void
    {
        $this->id = $id;
    }

    // Getter
    public function getId(): int
    {
        return $this->id;
    }

    // Methode
    public function doSomething(): void
    {
        print "Class01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // eine Referenz auf eine Instanz von Class01, die vom Konstruktor injiziert wird
    public function __construct(private readonly Class01 $class01)
    {
    }

    // klassenspezifische Methode
    public function doSomething(): void
    {
        // Änderung des Attributs von Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // Verwendung der Methode von Class01
        $this->class01->doSomething();
        // lokale Anzeige
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // eine Referenz auf eine Instanz von Class01, die vom Konstruktor injiziert wird
    public function __construct(private readonly Class01 $class01)
    {
    }

    // lokale Methode der Klasse
    public function doSomethingElse(): void
    {
        // Änderung des Attributs von Class01
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // Verwendung der Methode von Class01
        $this->class01->doSomething();
        // lokale Anzeige
        print "Class03->doSomethingElse\n";
    }
}

// test01 ----------------
function test01(): void
{
    // zwei Objekte, die auf zwei verschiedene Instanzen von [Class01] zugreifen
    $class02 = new Class02(new Class01());
    $class03 = new Class03(new Class01());
    // Prüfung
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test02 ----------------
function test02(): void
{
    // gemeinsam genutzte Instanz von [Class01]
    $class01 = new Class01();
    // zwei Objekte, die auf dieselbe Instanz von [Class01] zugreifen
    $class02 = new Class02($class01);
    $class03 = new Class03($class01);
    // Prüfung
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();
// test02
print "test02-----------------\n";
test02();

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

> php trait-03.php
test01-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (10)
Class03->doSomethingElse
test02-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (20)
Class03->doSomethingElse

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:

<?php

declare(strict_types=1);

trait Trait01
{
    // zu teilende Methode
    public function doSomething(): void
    {
        print "Trait01::doSomething...\n";
    }
}

class Class02
{
    // Einbindung von Trait01
    use Trait01 {
        // die Methode [Trait01::doSomething] ist in der Klasse
        // unter dem Namen [doSomethingInTrait] zugänglich
        Trait01::doSomething as doSomethingInTrait;
    }

    public function doSomething(): void
    {
        // Aufruf der Methode von Trait01
        $this->doSomethingInTrait();
        // lokale Anzeige
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // Einbindung von Trait01
    use Trait01;

    // lokale Methode der Klasse
    public function doSomethingElse(): void
    {
        // Aufruf der Methode von Trait01
        $this->doSomething();
        // lokale Anzeige
        print "Class03->doSomethingElse\n";
    }
}

// Test ----------------
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

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

1
2
3
4
5
> php trait-04.php
Trait01::doSomething...
Class02->doSomething
Trait01::doSomething...
Class03->doSomethingElse

In diesem Anwendungsfall kann der Trait [Trait01] ohne Weiteres durch eine Klasse ersetzt werden. Das zeigt das folgende [trait-05.php]-Skript:

<?php

declare(strict_types=1);

// weder instanziierbare noch ableitbare Klasse, die nur statische Methoden enthält
final class Class01
{
    // privater Konstruktor: keine Instanziierung außerhalb der Klasse möglich
    private function __construct()
    {
    }

    // zu teilende statische Methode
    public static function doSomething(): void
    {
        print "Class01::doSomething...\n";
    }
}

class Class02
{
    public function doSomething(): void
    {
        // Aufruf der statischen Methode von Class01
        Class01::doSomething();
        // lokale Anzeige
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // lokale Methode der Klasse
    public function doSomethingElse(): void
    {
        // Aufruf der statischen Methode von Class01
        Class01::doSomething();
        // lokale Anzeige
        print "Class03->doSomethingElse\n";
    }
}

// Test ----------------
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

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

1
2
3
4
5
> php trait-05.php
Class01::doSomething...
Class02->doSomething
Class01::doSomething...
Class03->doSomethingElse

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:

<?php

declare(strict_types=1);

trait Trait01
{
    // Attribut
    private int $i = 0;

    // zu teilende Methode
    public function doSomethingInTrait01(): void
    {
        // Änderung von Trait01::$i
        $this->i++;
        // Anzeige
        print "Trait01::doSomethingInTrait01... i=$this->i\n";
    }
}

class Class02
{
    // für abgeleitete Klassen zugängliches Attribut
    protected int $j = 0;

    // Methode
    public function doSomethingInClass02(): void
    {
        // Änderung von Class02::$j
        $this->j += 10;
        // Anzeige
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

// abgeleitete Klasse
class Class03 extends Class02
{
    // erbt Class02::$j und bindet Trait01::$i ein
    use Trait01;

    // Methode
    public function doSomethingInClass03(): void
    {
        // Verwendung der Methode von Trait01
        $this->doSomethingInTrait01();
        // Änderung von Trait01::$i
        $this->i += 100;
        // Änderung von Class03::$j (==Class02::$j)
        $this->j += 1000;
        // Anzeige
        print "Class03->doSomethingInClass03... i=$this->i, j=$this->j\n";
    }
}

// Test ----------------
(new Class02())->doSomethingInClass02();
(new Class03())->doSomethingInClass03();

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

1
2
3
4
> php trait-06.php
Class02->doSomethingInClass02... j=10
Trait01::doSomethingInTrait01... i=1
Class03->doSomethingInClass03... i=101, j=1000

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:

<?php

declare(strict_types=1);

class Class01
{
    // Attribut
    private int $i = 0;

    // Getter und Setter
    public function getI(): int
    {
        return $this->i;
    }

    public function setI(int $i): void
    {
        $this->i = $i;
    }

    // Methode
    public function doSomethingInClass01(): void
    {
        // Änderung von Class01::$i
        $this->i++;
        // Anzeige
        print "Class01->doSomethingInClass01... i=$this->i\n";
    }
}

class Class02
{
    // für abgeleitete Klassen zugängliches Attribut
    protected int $j = 0;

    // klassenspezifische Methode
    public function doSomethingInClass02(): void
    {
        // Änderung von Class02::$j
        $this->j += 10;
        // Anzeige
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

class Class03 extends Class02
{
    // eine Referenz auf eine Instanz von Class01, die vom Konstruktor injiziert wird
    public function __construct(private readonly Class01 $class01)
    {
    }

    // lokale Methode der Klasse
    public function doSomethingInClass03(): void
    {
        // Verwendung der Methode von Class01
        $this->class01->doSomethingInClass01();
        // Änderung von Class01::$i
        $i = $this->class01->getI();
        $i += 100;
        $this->class01->setI($i);
        // Änderung von Class03::$j
        $this->j += 1000;
        // Anzeige
        print "Class03->doSomethingInClass03... i=$i, j=$this->j\n";
    }
}

// Test ----------------
$class02 = new Class02();
$class03 = new Class03(new Class01());
$class02->doSomethingInClass02();
$class03->doSomethingInClass03();

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

1
2
3
4
> php trait-07.php
Class02->doSomethingInClass02... j=10
Class01->doSomethingInClass01... i=1
Class03->doSomethingInClass03... i=101, j=1000

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 Klasse C implementiert die Schnittstelle I, aber bestimmte Methoden – die in den abgeleiteten Klassen definiert werden müssen – werden in der Klasse C als 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]):

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

abstract class AbstractClass implements Interface1
{
    // für abgeleitete Klassen zugängliche Attribute
    protected int $attr1 = 11;
    protected int $attr2 = 12;

    // Getter und Setter
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // implementierte Methode
    #[\Override]
    public function doSomething(): void
    {
        print "AbstractClass::doSomething [$this->attr1,$this->attr2]\n";
    }

    // nicht implementierte Methode
    #[\Override]
    abstract public function doSomethingElse(): void;
}

// abgeleitete Klasse 1
class Class1 extends AbstractClass
{
    // Attribut
    private int $attr3 = 13;

    // Getter und Setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // Implementierung von doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// abgeleitete Klasse 2
class Class2 extends AbstractClass
{
    // Attribut
    private int $attr4 = 14;

    // Getter und Setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // Implementierung von doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// externe Funktion
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// Tests
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// „fluente" Setter lassen sich verketten
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

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

1
2
3
4
5
6
7
> php trait-08.php
AbstractClass::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
AbstractClass::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
AbstractClass::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

Nun setzen wir Lösung 2 mit dem Skript [trait-09.php] um. Dabei wird die abstrakte Klasse durch einen Trait ersetzt:

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

trait Trait1
{
    // Attribute
    private int $attr1 = 11;
    private int $attr2 = 12;

    // Getter und Setter
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // implementierte Methode
    #[\Override]
    public function doSomething(): void
    {
        print "Trait1::doSomething [$this->attr1,$this->attr2]\n";
    }
}

// Klasse 1
class Class1 implements Interface1
{
    // Verwendung des Traits
    use Trait1;

    // Attribut
    private int $attr3 = 13;

    // Getter und Setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // Implementierung von doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// Klasse 2
class Class2 implements Interface1
{
    // Verwendung des Traits
    use Trait1;

    // Attribut
    private int $attr4 = 14;

    // Getter und Setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // Implementierung von doSomethingElse
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// externe Funktion, die die Schnittstelle verwendet
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// Tests
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// „fluente" Setter lassen sich verketten
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

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

1
2
3
4
5
6
7
> php trait-09.php
Trait1::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
Trait1::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
Trait1::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

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:

<?php

declare(strict_types=1);

// ein Trait, das etwas von den Klassen verlangt, die es verwenden
trait CounterTrait
{
    // Trait-Konstante (PHP 8.2)
    public const int STEP = 10;

    // statisches Attribut: jede verwendende Klasse hat ihr eigenes
    private static int $nbInstances = 0;

    // Instanzattribut
    private int $counter = 0;

    // statische Trait-Methode
    public static function getNbInstances(): int
    {
        return self::$nbInstances;
    }

    // abstrakte Methode: die verwendende Klasse muss sie definieren (Signatur seit PHP 8.0 geprüft)
    abstract protected function getName(): string;

    // wird vom Konstruktor der verwendenden Klasse aufgerufen
    private function register(): void
    {
        self::$nbInstances++;
    }

    // konkrete Methode, die die abstrakte Methode und die Konstante verwendet
    public function increment(): static
    {
        $this->counter += self::STEP;
        print "{$this->getName()}: counter=$this->counter\n";
        return $this;
    }
}

class Car
{
    use CounterTrait;

    public function __construct(private string $registration)
    {
        $this->register();
    }

    // Implementierung der abstrakten Methode des Traits
    #[\Override]
    protected function getName(): string
    {
        return "Car[$this->registration]";
    }
}

class Bike
{
    use CounterTrait;

    public function __construct()
    {
        $this->register();
    }

    #[\Override]
    protected function getName(): string
    {
        return "Bike";
    }
}

// Tests
(new Car("AB-123-CD"))->increment()->increment();
new Car("EF-456-GH");
(new Bike())->increment();
// jede Klasse hat ihr eigenes statisches Attribut
print "number of cars: " . Car::getNbInstances() . "\n";
print "number of bikes: " . Bike::getNbInstances() . "\n";
// die Trait-Konstante ist über die Klasse zugänglich, nicht über das Trait
print "step: " . Car::STEP . "\n";
try {
    print CounterTrait::STEP . "\n";
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}
// eine Klasse, die das Trait verwendet, muss die abstrakte Methode implementieren
// class Plane { use CounterTrait; }  // Fatal error: Class Plane contains 1 abstract method...

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

1
2
3
4
5
6
7
8
> php trait-10.php
Car[AB-123-CD]: counter=10
Car[AB-123-CD]: counter=20
Bike: counter=10
number of cars: 2
number of bikes: 1
step: 10
Error: Cannot access trait constant CounterTrait::STEP directly

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.