traits.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: c1f37a6c270aadbbb3da56a3973ffd62197adf2b Maintainer: simp Status: ready -->
<!-- Reviewed: no -->
 <sect1 xml:id="language.oop5.traits" xmlns="http://docbook.org/ns/docbook">
  <title>Traits</title>
  <para>
   In PHP gibt es eine Methode der Wiederverwendung von Code, die Traits
   genannt wird.
  </para>
  <para>
   Traits sind ein Mechanismus zur Wiederverwendung von Code, der in
   Programmiersprachen mit einfacher Vererbung wie PHP verwendet wird. Ein
   Trait kann verwendet werden, um den Beschränkungen der einfachen Vererbung
   auszuweichen, indem er erlaubt, dass Mengen von Methoden frei in
   mehreren unabhängigen Klassen, die in verschiedenen Klassenhierarchien
   stecken, wiederzuverwenden. Die Semantik der Kombination von Traits und
   Klassen ist so definiert, dass die Komplexität reduziert wird und die
   üblichen Probleme vermeidet, die mit Mehrfachvererbung und Mixins in
   Verbindung gebracht werden.
  </para>
  <para>
   Ein Trait hat Ähnlichkeit mit einer Klasse, ist aber nur dafür vorgesehen,
   Funktionalität in einer feingranularen und konsistenten Art und Weise zu
   bündeln. Es ist nicht möglich einen Trait alleinstehend zu instantiieren.
   Es handelt sich um einen Zusatz zur traditionellen Vererbung und erlaubt
   horizontale Komposition von Verhaltensweisen, &dh; die Verwendung von
   Klassenmethoden ohne Vererbung vorauszusetzen.
  </para>

  <example xml:id="language.oop5.traits.basicexample">
    <title>Trait-Beispiel</title>
    <programlisting role="php">
<![CDATA[
<?php

trait TraitA {
    public function sayHello() {
        echo 'Hello';
    }
}

trait TraitB {
    public function sayWorld() {
        echo 'World';
    }
}

class MyHelloWorld
{
    use TraitA, TraitB; // Eine Klasse kann mehrere Traits verwenden

    public function sayHelloWorld() {
        $this->sayHello();
        echo ' ';
        $this->sayWorld();
        echo "!\n";
    }
}

$myHelloWorld = new MyHelloWorld();
$myHelloWorld->sayHelloWorld();

?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Hello World!
]]>
    </screen>
   </example>

  <sect2 xml:id="language.oop5.traits.precedence">
   <title>Rangfolge</title>
   <para>
    Methoden der aktuellen Klasse überschreiben Methoden, welche von Traits
    definiert wurden. Jene wiederum überschreiben von Elternklassen geerbte
    Methoden.
   </para>
   <example xml:id="language.oop5.traits.precedence.examples.ex1">
    <title>Rangfolge-Beispiel</title>
    <para>
     Die Methode <literal>sayHello</literal> der Basisklasse wird durch die
     gleichnamige Methode aus dem Trait überschrieben.
    </para>
    <programlisting role="php">
<![CDATA[
<?php
class Base {
    public function sayHello() {
        echo 'Hallo ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'Welt!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Hallo Welt!
]]>
    </screen>
   </example>
   <example xml:id="language.oop5.traits.precedence.examples.ex2">
    <title>Weiteres Beispiel für Rangfolge</title>
    <programlisting role="php">
<![CDATA[
<?php
trait HelloWorld {
    public function sayHello() {
        echo 'Hallo Welt!';
    }
}

class TheWorldIsNotEnough {
    use HelloWorld;
    public function sayHello() {
        echo 'Hallo Universum!';
    }
}

$o = new TheWorldIsNotEnough();
$o->sayHello();
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Hallo Universum!
]]>
    </screen>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.multiple">
   <title>Mehrere Traits</title>
   <para>
    Mehrere Traits können durch eine kommaseparierte Auflistung im
    <literal>use</literal>-Statement zu einer Klasse hinzugefügt werden.
   </para>
   <example xml:id="language.oop5.traits.multiple.ex1">
    <title>Verwendung mehrerer Traits</title>
    <programlisting role="php">
<![CDATA[
<?php
trait Hello {
    public function sayHello() {
        echo 'Hallo ';
    }
}

trait World {
    public function sayWorld() {
        echo ' Welt';
    }
}

class MyHelloWorld {
    use Hello, World;
    public function sayExclamationMark() {
        echo '!';
    }
}

$o = new MyHelloWorld();
$o->sayHello();
$o->sayWorld();
$o->sayExclamationMark();
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Hallo Welt!
]]>
    </screen>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.conflict">
   <title>Konfliktauflösung</title>
   <para>
    Falls zwei Traits eine Methode mit gleichem Namen einfügen, so wird ein
    Fatal Error erzeugt, wenn der Konflikt nicht explizit aufgelöst wird.
   </para>
   <para>
    Um einen Namenskonflikt zwischen Traits in der gleichen Klasse aufzulösen
    muss der <literal>insteadof</literal>-Operator verwendet werden, um
    genau eine der Methoden des Konflikts auszuwählen.
   </para>
   <para>
    Da dies es nur erlaubt Methoden auszuschließen kann der
    <literal>as</literal>-Operator verwendet werden, um einen Alias zu einer der
    Methoden hinzuzufügen. Es ist zu beachten, dass der <literal>as</literal>
    Operator die Methode nicht umbenennt, und auch keine andere Methode
    beeinflusst.
   </para>
   <example xml:id="language.oop5.traits.conflict.ex1">
    <title>Konfliktauflösung</title>
    <para>
      In diesem Beispiel verwendet die Klasse Talker die Traits A und B.
      Nachdem A und B sich widersprechende Methoden besitzen definiert die
      Klasse, dass sie die Variante von smallTalk aus dem Trait B und die
      Variante von bigTalk des Traits A verwenden möchte.
    </para>
    <para>
      Die Klasse Aliased_Talker verwendet den <literal>as</literal>-Operator,
      damit sie außerdem die Implementierung der bigTalk-Methode von B unter dem
      Alias <literal>talk</literal> verwenden kann.
    </para>
    <programlisting role="php" annotations="non-interactive">
<![CDATA[
<?php
trait A {
    public function smallTalk() {
        echo 'a';
    }
    public function bigTalk() {
        echo 'A';
    }
}

trait B {
    public function smallTalk() {
        echo 'b';
    }
    public function bigTalk() {
        echo 'B';
    }
}

class Talker {
    use A, B {
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
    }
}

class Aliased_Talker {
    use A, B {
        B::smallTalk insteadof A;
        A::bigTalk insteadof B;
        B::bigTalk as talk;
    }
}
?>
]]>
    </programlisting>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.visibility">
   <title>Veränderung der Sichtbarkeit von Methoden</title>
   <para>
    Mit der <literal>as</literal>-Syntax ist es ebenso möglich, die
    Sichtbarkeit einer Methode in der darstellenden Klasse zu verändern.
   </para>
   <example xml:id="language.oop5.traits.visibility.ex1">
    <title>Veränderung der Sichtbarkeit von Methoden</title>
    <programlisting role="php" annotations="non-interactive">
<![CDATA[
<?php
trait HelloWorld {
    public function sayHello() {
        echo 'Hallo Welt!';
    }
}

// Ändern der Sichtbarkeit von sayHello
class MyClass1 {
    use HelloWorld { sayHello as protected; }
}

// Alias der Methode mit geänderter Sichtbarkeit
// Die Sichtbarkeit von sayHello bleibt unverändert
class MyClass2 {
    use HelloWorld { sayHello as private myPrivateHello; }
}
?>
]]>
    </programlisting>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.composition">
   <title>Trait-Zusammensetzung aus Traits</title>
   <para>
    Ebenso wie Klassen können auch Traits andere Traits verwenden. Indem
    man einen oder mehrere Traits in einer Traitdefinition verwendet kann man
    Traits entweder teilweise oder vollständig aus Methoden, welche in anderen
    Traits definiert sind, zusammensetzen.
   </para>
   <example xml:id="language.oop5.traits.composition.ex1">
    <title>Trait-Zusammensetzung aus Traits</title>
    <programlisting role="php">
<![CDATA[
<?php
trait Hello {
    public function sayHello() {
        echo 'Hallo ';
    }
}

trait World {
    public function sayWorld() {
        echo 'Welt!';
    }
}

trait HelloWorld {
    use Hello, World;
}

class MyHelloWorld {
    use HelloWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
$o->sayWorld();
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Hallo Welt!
]]>
    </screen>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.abstract">
   <title>Abstrakte Traitmember</title>
   <para>
    Traits unterstützen auch die Verwendung von abstrakten Methoden, um
    darstellenden Klassen Anforderungen vorzugeben. Es werden öffentliche,
    geschützte und private Methoden unterstützt. Vor PHP 8.0.0 wurden nur
    öffentliche und geschützte abstrakte Methoden unterstützt.
   </para>
   <caution>
    <simpara>
     Seit PHP 8.0.0 muss die Signatur einer konkreten Methode den
     <link linkend="language.oop.lsp">Regeln zur Signaturkompatibilität</link>
     entsprechen; zuvor durfte ihre Signatur davon abweichen.
    </simpara>
   </caution>
   <example xml:id="language.oop5.traits.abstract.ex1">
    <title>Ausdrücken von Anforderungen durch abstrakte Methoden</title>
    <programlisting role="php">
<![CDATA[
<?php
trait Hello {
    public function sayHelloWorld() {
       echo 'Hallo'.$this->getWorld();
    }
    abstract public function getWorld();
}

class MyHelloWorld {
    private $world;
    use Hello;
    public function getWorld() {
        return $this->world;
    }
    public function setWorld($val) {
        $this->world = $val;
    }
}
?>
]]>
    </programlisting>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.static">
   <title>Statische Traitmember</title>
   <para>
    Traits unterstützen sowohl statische Variablen, statische Methoden und
    statische Eignschaften.
   </para>
   <note>
    <para>
     Seit PHP 8.1.0 sind der Aufruf einer statischen Methode oder der Zugriff
     auf eine statische Eigenschaft direkt in einem Trait veraltet. Auf
     statische Methoden und Eigenschaften sollte nur in einer Klasse
     zugegriffen werden, die den Trait verwendet.
    </para>
   </note>
   <example xml:id="language.oop5.traits.static.ex1">
    <title>Statische Variablen</title>
    <programlisting role="php">
<![CDATA[
<?php

trait Counter
{
    public function inc()
    {
        static $c = 0;
        $c = $c + 1;
        echo "$c\n";
    }
}

class C1
{
    use Counter;
}

class C2
{
    use Counter;
}

$o = new C1();
$o->inc();
$p = new C2();
$p->inc();

?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
1
1
]]>
    </screen>
   </example>
   <example xml:id="language.oop5.traits.static.ex2">
    <title>Statische Methoden</title>
    <programlisting role="php">
<![CDATA[
<?php

trait StaticExample
{
    public static function doSomething()
    {
        return 'Tue etwas';
    }
}

class Example
{
    use StaticExample;
}

echo Example::doSomething();

?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
Doing something
]]>
    </screen>
   </example>
   <example xml:id="language.oop5.traits.static.ex3">
    <title>Statische Eigenschaften</title>
    <caution>
     <simpara>
      Vor PHP 8.3.0 wurden statische Eigenschaften, die in einem Trait
      definiert waren, von allen Klassen in derselben Vererbungshierarchie, die
      diesen Trait verwendeten, gemeinsam genutzt.
      Seit PHP 8.3.0 wird eine statische Eigenschaft, die von einer Kindklasse
      über einen Trait verwendet wird, als von der in der Elternklasse
      definierte Eigenschaft unterschieden betrachtet.
     </simpara>
    </caution>
    <programlisting role="php">
     <![CDATA[
<?php

trait T
{
    public static $counter = 1;
}

class A
{
    use T;

    public static function incrementCounter()
    {
        static::$counter++;
    }
}

class B extends A
{
    use T;
}

A::incrementCounter();

echo A::$counter, "\n";
echo B::$counter, "\n";

?>
]]>
    </programlisting>
    &example.outputs.83;
    <screen>
<![CDATA[
2
1
]]>
    </screen>
   </example>
  </sect2>

  <sect2 xml:id="language.oop5.traits.properties">
   <title>Eigenschaften</title>
   <para>
    Traits können ebenfalls Eigenschaften definieren.
   </para>
   <example xml:id="language.oop5.traits.properties.example">
    <title>Eigenschaften definieren</title>
    <programlisting role="php">
<![CDATA[
<?php

trait PropertiesTrait
{
    public $x = 1;
}

class PropertiesExample
{
    use PropertiesTrait;
}

$example = new PropertiesExample();
$example->x;

?>
]]>
    </programlisting>
   </example>
   <para>
    Definiert ein Trait eine Eigenschaft, dann kann eine Klasse keine Eigenschaft
    mit dem selben Namen definieren, es sei denn, sie ist kompatibel (selbe
    Sichtbarkeit und Typ, readonly-Modifikator und Initialwert); andernfalls wird
    ein fataler Fehler auftreten.
   </para>
   <example xml:id="language.oop5.traits.properties.conflicts">
    <title>Konfliktauflösung</title>
    <programlisting role="php">
<![CDATA[
<?php
trait PropertiesTrait {
    public $same = true;
    public $different1 = false;
    public bool $different2;
    public bool $different3;
}

class PropertiesExample {
    use PropertiesTrait;
    public $same = true;
    public $different1 = true; // Fatal error
    public string $different2; // Fatal error
    readonly protected bool $different3; // Fatal error
}
?>
]]>
    </programlisting>
   </example>
  </sect2>

 <sect2 xml:id="language.oop5.traits.constants">
  <title>&Constants;</title>
  <para>
   Seit PHP 8.2.0 können Traits auch Konstanten definieren.
  </para>
  <example xml:id="language.oop5.traits.constants.example">
   <title>Definieren von Konstanten</title>
   <programlisting role="php">
<![CDATA[
<?php
trait ConstantsTrait {
    public const FLAG_MUTABLE = 1;
    final public const FLAG_IMMUTABLE = 5;
}

class ConstantsExample {
    use ConstantsTrait;
}

$example = new ConstantsExample;
echo $example::FLAG_MUTABLE;
?>
]]>
   </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
1
]]>
    </screen>
  </example>
  <para>
   Wenn ein Trait eine Konstante definiert, kann eine Klasse keine Konstante
   mit demselben Namen definieren, es sei denn, sie ist kompatibel (dieselbe
   Sichtbarkeit, derselbe Initialwert und dieselbe Finalität), andernfalls
   wird ein fataler Fehler ausgegeben.
  </para>
  <example xml:id="language.oop5.traits.constants.conflicts">
   <title>Konfliktauflösung</title>
   <programlisting role="php">
<![CDATA[
<?php
trait ConstantsTrait {
    public const FLAG_MUTABLE = 1;
    final public const FLAG_IMMUTABLE = 5;
}

class ConstantsExample {
    use ConstantsTrait;
    public const FLAG_IMMUTABLE = 5; // Fatal error
}
?>
]]>
   </programlisting>
  </example>
 </sect2>

 <sect2 xml:id="language.oop5.traits.final-methods">
  <title>Finale Methoden</title>
  <simpara>
   Seit PHP 8.3.0 kann der Modifikator
   <link linkend="language.oop5.final">final</link> mit dem Operator
   <literal>as</literal> auf Methoden angewendet werden, die aus Traits
   importiert wurden. Dies kann verwendet werden, um zu verhindern, dass
   Kindklassen die Methode überschreiben. Die Klasse, die den Trait verwendet,
   kann die Methode jedoch weiterhin überschreiben.
  </simpara>
  <example xml:id="language.oop5.traits.final-methods.example">
   <title>Definieren einer Methode aus einem Trait als <literal>final</literal></title>
   <programlisting role="php">
    <![CDATA[
<?php

trait CommonTrait
{
    public function method()
    {
        echo 'Hello';
    }
}

class FinalExampleA
{
    use CommonTrait {
        CommonTrait::method as final; // Das "final" verhindert, dass Kindklassen
                                      // die Methode überschreiben.
    }
}

class FinalExampleB extends FinalExampleA
{
    public function method() {}
}

?>
]]>
   </programlisting>
    &example.outputs.similar;
    <screen>
<![CDATA[
Fatal error: Cannot override final method FinalExampleA::method() in ...
]]>
    </screen>
  </example>
 </sect2>

 </sect1>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->