moin, schön und klar erklärt aber das weis ich. Meine Frage war aber ne andere. Sorry wenn ich nicht besser ausdrücken kann. Ich hoffer ein Beispiel hilft: ~~~php class BarObject { public $quz; public $tok } trait BazTrait { public function doSomethingWithObject() : void { /* any code */; } } class FooModel { use BazTrait; private $_barObj; public function __construct( BarObject $bar ) { $this->_barObj = $bar; } } $f = new FooModel( new BarObject ); $f->doAnything( ~~~ `BarObject` soll irgend n Objekt sein und das _Trait_ `BazTrait` soll Methoden für Objekte in der Art von `BarObject` bereit stellen. Die Frage ist nun: kann man getrost andere Instanzen & Klassen die es schon in `FooModel` gibt, im _Trait_ `BazTrait` verwenden? Ich mein, dann ist die Gefahr der Kopplung da. Ein weiteres Beispiel an dem Codebeispiel: ~~~php trait BazTrait { public function doSomethingWithObject() : void { $this->_fuzObj /* any code with FuzObject */; } } class FooModel { use BazTrait; private $_barObj; private $_fuzObj; public function __construct( BarObject $bar, FuzObject $fuz ) { $this->_barObj = $bar; $this->_fuzObj = $fuz; } } ~~~ Beim _Trait_ `BazTrait` habe ich, in der Methode `doAnythingWithObject()`, den _Code_ spezifiziert mit `$this->_fuzObj`. Im ersten Beispiel ist es gleich wer das Trait `BazTrait` verwendet, da es nicht gekoppelt und spezifisch ist, nur ein Objekt eben das das _Trait_ behandelt. Im Zweiten Beispiel ist das nicht der Fall, da entsteht eine kopplung mit der Klasse `FooModel`. Und Dahin gehend meine Fragen-Liste in der Eingangsfrage: * gibt es Konventionen * Muss man _Traits_ von anderen Klassen & Instanzen abschiermen, sodass sie Autonom sind, oder nicht abschiermen * wann ist eine Trait Verwendung Sinnvoll Ich hoffe es ist verständlicher geworden. lgmb

moin, schön und klar erklärt aber das weis ich. Meine Frage war aber ne andere. Sorry wenn ich nicht besser ausdrücken kann. Ich hoffer ein Beispiel hilft: ~~~php class BarObject { public $quz; public $tok } trait BazTrait { public function doSomethingWithObject() : void { /* any code */; } } class FooModel { use BazTrait; private $_barObj; public function __construct( BarObject $bar ) { $this->_barObj = $bar; } } $f = new FooModel( new BarObject ); $f->doAnything( ~~~ `BarObject` soll irgend n Objekt sein und das _Trait_ `BazTrait` soll Methoden für Objekte in der Art von `BarObject` bereit stellen. Die Frage ist nun: kann man getrost andere Instanzen & Klassen die es schon in `FooModel` gibt, im _Trait_ `BazTrait` verwenden? Ich mein, dann ist die Gefahr der Kopplung da. Ein weiteres Beispiel an dem Codebeispiel: ~~~php trait BazTrait { public function doSomethingWithObject() : void { $this->_fuzObj /* any code with FuzObject */; } } class FooModel { use BazTrait; private $_barObj; private $_fuzObj; public function __construct( BarObject $bar, FuzObject $fuz ) { $this->_barObj = $bar; $this->_fuzObj = $fuz; } } ~~~ Beim _Trait_ `BazTrait` habe ich, in der Methode `doAnythingWithObject()`, den _Code_ spezifiziert mit `$this->_fuzObj`. Im ersten Beispiel ist es gleich wer das Trait `BazTrait` verwendet, da es nicht gekoppelt und spezifisch ist, nur ein Objekt eben das das _Trait_ behandelt. Im Zweiten Beispiel ist das nicht der Fall, da entsteht eine kopplung mit der Klasse `FooModel`. Und Dahin gehend meine Fragen-Liste in der Eingangsfrage: * gibt es Konventionen * Muss man _Traits_ von anderen Klassen & Instanzen abschiermen so das sie Autonom sind oder nich lgmb

moin, schön und klar erklärt aber das weis ich. Meine Frage war aber ne andere. Sorry wenn ich nicht besser ausdrücken kann. Ich hoffer ein Beispiel hilft: ~~~php class BarObject { public $quz; public $tok } trait BazTrait { public function doSomethingWithObject() : void { /* any code */; } } class FooModel { use BazTrait; private $_barObj; public function __construct( BarObject $bar ) { $this->_barObj = $bar; } } $f = new FooModel( new BarObject ); $f->doAnything( ~~~ `BarObject` soll irgend n Objekt sein und das _Trait_ `BazTrait` soll Methoden für Objekte in der Art von `BarObject` bereit stellen. Die Frage ist nun: kann man getröst andere Instanzen & Klassen die es schon in `FooModel` gibt, verwenden? Ich mein dann ist die gefahr der Kopplung da, der abhängigkeit derer Klassen. beispiel an dem erweiterten Codebeispiel: ~~~php trait BazTrait { public function doSomethingWithObject() : void { $this->_fuzObj /* any code with FuzObject */; } } class FooModel { use BazTrait; private $_barObj; private $_fuzObj; public function __construct( BarObject $bar, FuzObject $fuz ) { $this->_barObj = $bar; $this->_fuzObj = $fuz; } } ~~~ Beim _Trait_ `BazTrait` habe ich, in der Methode `doAnythingWithObject()`, den _Code_ spezifiziert mit `$this->_fuzObj`. Im ersten Beispiel ist es gleich wer das Trait `BarTrait` verwendet, da es nicht gekoppelt und spezifiisch ist, nur ein Objekt eben das das _Trait_ behandelt. Im Zweiten Beispiel ist das nicht der Fall, da entsteht eine kopplung mit der Klasse `FooModel`. Und Dahin gehend meine Fragen-Liste in der Eingangsfrage kurz: * gibt es Konventionen * Muss man _Traits_ von anderen Klassen & Instanzen abschiermen so das sie Autonom sind oder nich lgmb