PHP-Klassen und -Objekte – Eigenschaften

Seit PHP 5.4.0 hat PHP eine Methode zur Code-Wiederverwendung namens Traits implementiert.

Traits ist ein Code-Wiederverwendungsmechanismus, der für Sprachen mit einfacher Vererbung wie PHP vorbereitet ist. Merkmale sollen die Einschränkungen von Sprachen mit einfacher Vererbung verringern und Entwicklern die freie Wiederverwendung von Methodensätzen in unabhängigen Klassen innerhalb verschiedener Hierarchien ermöglichen. Die Semantik von Merkmalen und die Klassenzusammensetzung definieren eine Möglichkeit, die Komplexität zu reduzieren und die typischen Probleme zu vermeiden, die mit traditioneller Mehrfachvererbung und Mixins verbunden sind.

Eigenschaften ähneln einer Klasse, sind jedoch lediglich darauf ausgelegt, Funktionalität auf feinkörnige und konsistente Weise zu kombinieren. Ein Merkmal kann nicht allein instanziiert werden. Es fügt der herkömmlichen Vererbung eine Kombination horizontaler Funktionen hinzu, d. h. Mitglieder von Anwendungsklassen müssen nicht vererbt werden.

Beispiel #1 Merkmalsbeispiel

trait ezcReflectionReturnInfo{
    function getReturnType(){}
    function getReturnDescription(){}
}
class ezcReflectionMethod extends ReflectionMethod{
    use ezcReflectionReturnInfo;
}
class ezcReflectionFunction extends ReflectionFunction{
    use ezcReflectionReturnInfo;
}

Priorität

Von der Basisklasse geerbte Mitglieder werden durch von der Eigenschaft eingefügte Mitglieder überschrieben. Die Rangfolge besteht darin, dass Mitglieder der aktuellen Klasse die Methoden des Merkmals überschreiben und das Merkmal die geerbten Methoden überschreibt.

Beispiel #2 Prioritätsbeispiel

Von der Basisklasse geerbte Mitglieder werden von der MyHelloWorld-Methode im eingefügten SayWorld-Merkmal überschrieben. Sein Verhalten stimmt mit den in der MyHelloWorld-Klasse definierten Methoden überein. Die Rangfolge besteht darin, dass die Methoden in der aktuellen Klasse die Trait-Methode überschreiben und die Trait-Methode wiederum die Methode in der Basisklasse überschreibt:

class Base{
    public function sayHello(){
        echo "Hello ";
    }
}
trait SayWorld{
    public function sayHello(){
        parent::sayHello();
        echo 'World!';
    }
}
class MyHelloWorld extends Base{
    use SayWorld;
}
$o = new MyHelloWorld();
$o -> sayHello();

Ausgabeergebnis:

Hallo Welt!

Beispiel #3 Ein weiteres Beispiel für die Prioritätsreihenfolge

trait HelloWorld{
    public function sayHello(){
        echo 'Hello World!';
    }
}
class TheWorldIsNotEnough{
    use HelloWorld;
    public function sayHello(){
        echo 'Hello Universe!';
    }
}
$o = new TheWorldIsNotEnough;
$o -> sayHello();

Ausgabeergebnis:

Hallo Universum!

Mehrere Merkmale

Durch Komma getrennt werden mehrere Merkmale in der Verwendungsanweisung aufgelistet und können alle in eine Klasse eingefügt werden.

Beispiel #4 Verwendung mehrerer Merkmale

trait Hello{
    public function sayHello(){
        echo 'Hello ';
    }
}
trait World{
    public function sayWorld(){
        echo 'World';
    }
}
class MyHelloWorld{
    use Hello,World;
    public function sayExclamationMark(){
        echo '!';
    }
}
$o = new MyHelloWorld();
$o -> sayHello();
$o -> sayWorld();
$o -> sayExclamationMark();

Ausgabeergebnis:

Hallo Welt!

Konfliktlösung

Wenn beides Wenn Traits eine Methode mit demselben Namen einfügen, tritt ein schwerwiegender Fehler auf, wenn der Konflikt nicht explizit gelöst wird.

Um den Namenskonflikt mehrerer Merkmale in derselben Klasse zu lösen, müssen Sie den Statt-Operator verwenden, um explizit anzugeben, welche der widersprüchlichen Methoden verwendet werden sollen.

Mit der obigen Methode können nur andere Methoden ausgeschlossen werden. Der as-Operator kann eine der widersprüchlichen Methoden unter einem anderen Namen einführen.

Beispiel #5 Konfliktlösung

In diesem Beispiel verwendet Talker die Merkmale A und B. Da A und B widersprüchliche Methoden haben, definieren sie die Verwendung von smallTalk aus Merkmal B und bigTalk aus Merkmal A.

Aliased_Talker verwendet den as-Operator, um talk als Alias ​​von Bs bigTalk zu definieren.

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;
    }
}
$t = new Talker;
$t->smallTalk(); //b
$t->bigTalk(); //A
$at = new Aliased_Talker;
$at->smallTalk(); //b
$at->bigTalk(); //A
$at->talk(); //B

Ändern Sie die Zugriffskontrolle der Methode

Mit der as-Syntax können Sie auch die Zugriffskontrolle der Methode anpassen.

Beispiel #6 Methodenzugriffskontrolle ändern

trait HelloWorld{
    public function sayHello(){
        echo 'Hello World!';
    }
}
//修改sayHello的访问控制
class MyClass1{
    use HelloWorld{
        sayHello as protected;
    }
}
//给方法一个改变了访问控制的别名
//原版sayHello的访问控制则没有发生变化
class MyClass2{
    use HelloWorld{sayHello as private myPrivateHello;}
}

Merkmale aus Merkmalen zusammensetzen

So wie Klassen Merkmale verwenden können, können auch andere Merkmale Merkmale verwenden. Durch die Verwendung eines oder mehrerer Merkmale bei der Definition eines Merkmals können einige oder alle Mitglieder anderer Merkmale kombiniert werden.

Beispiel #7 Merkmal aus Merkmal zusammensetzen

trait Hello{
    public function sayHello(){
        echo 'Hello ';
    }
}
trait World{
    public function sayWorld(){
        echo 'World!';
    }
}
trait HelloWorld{
    use Hello,World;
}
class MyHelloWorld{
    use HelloWorld;
}
$o = new MyHelloWorld;
$o -> sayHello();
$o -> sayWorld();

Ausgabeergebnis:

Hallo Welt!

Abstraktes Mitglied von Merkmal

Um Anforderungen an die verwendeten Klassen durchzusetzen, unterstützen Traits den Einsatz abstrakter Methoden.

Beispiel Nr. 8 stellt die Durchsetzung durch abstrakte Methoden dar.

trait Hello{
    public function sayHelloWorld(){
        echo 'Hello'.$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;
    }
}

Statische Mitglieder von Trait

Statische Variablen können von Trait-Methoden referenziert, aber nicht durch Trait definiert werden . Aber Merkmale können statische Methoden für die Klassen definieren, in denen sie verwendet werden.

Beispiel #9 Statische Variable

trait Counter{
    public function inc(){
        static $c = 0;
        $c = $c + 1;
        echo "{$c}<br>";
    }
}
class C1{
    use Counter;
}
class C2{
    use Counter;
}
$o = new C1();
$o->inc(); //echo 1
$p = new C2;
$p->inc(); //echo 1

Beispiel #10 Statische Methode

trait StaticExample{
    public static function doSomething(){
        return 'Doing something.';
    }
}
class Example{
    use StaticExample;
}
Example::doSomething();

Ausgabeergebnis: Etwas tun.

Attribut

Trait kann auch Attribute definieren.

Beispiel #11 Attribute definieren

trait PropertiesTrait{
    public $x = 1;
}
class PropertiesExample{
    use PropertiesTrait;
}
$example = new PropertiesExample;
$example->x;

Wenn ein Merkmal ein Attribut definiert, kann die Klasse kein Attribut mit demselben Namen definieren, andernfalls wird ein Fehler generiert. Wenn die Definition der Eigenschaft in der Klasse mit ihrer Definition im Merkmal kompatibel ist (gleiche Sichtbarkeit und gleicher Anfangswert), dann ist die Fehlerstufe E_STRICT, andernfalls handelt es sich um einen schwerwiegenden Fehler.

Beispiel #12 Konflikt

trait PropertiesTrait{
    public $sname = true;
    public $different = false;
}
class PropertiesExample{
    use PropertiesTrait;
    public $sname = true; //Strict Standards
    public $different = true; //致命错误
}