moin, Ich habe eine Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. Ich nenne z.B. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer** aus der Klassengruppe. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_, Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über die selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe eine Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. Ich nenne z.B. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer** aus der Klassengruppe. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_, Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe eine Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. Ich nenne z.B. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer** aus der Klassengruppe. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_ Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe eine Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. Ich nenne z.B. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer** aus der Klassengruppe. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufgrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_ Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe eine Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer**. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufgrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_ Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe einen Klassengruppe, die, per Instanziierung, einen SQL Teilstring erzeugen. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer**. Die Klassen sind lose gekoppelt. Einige Klassen können sich gegenseitig, per _Consrtructor Injection_, aufgrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit dazugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PredicateInterface**, **FunctionInterface**)_ Übergabewerte, die sie dann zwischenspeichen und ergänzen `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte, per _Constructor Injection_, an den nächsten weiter zureichen. Alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ Kann man dieses Klassen Gebildes mit _Traits_ oder mit einer _Elternklasse_ realisieren? Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs' mit einer abstrakten Elternklasse realisiert, von der alle Klassen erben und dann die Elternklasse mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb

moin, Ich habe einen Klassen Gruppe die per Instanziierung einen SQL Teil string erzeugen. **In**, **Between**, **Cases**, **Arithmetic**, **LogicContainer**. Die Klassen sind lose gegoppelt. Einige Klassen können sich gegenseitig per _Consrtructor Injection_ aufgrufen: ~~~php new LogicContainer( new Between( /* Params */, LogicConstant::_AND ) ) ~~~ Jeder Klasse bekommt, per _Constructor Injection_ mit zugehörigem _Interface_ _(z.B. **ExpressionInterface**, **PrediucateInterface**, **FunctionInterface**)_ Übergabewerte, die sie dann zwischenspeicher und ergänzt `$this->addString( $expression->getString() )`{: .language-php}, um dann diese Zwischengespeicherten Werte an den nächsten per _Constructor Injection_ weiter zureichen. Da alle Klassen müssen über selben Methoden verfügen: ~~~php protected function addString ( string $string ) : void; public function getString () : string; ~~~ kann man es mit Trait oder mit extends zwischen Speichern. Ich sehe da _Pros_ & _Cons_: Hab ihr erfahrungen? Ich für meinen Teil habs mit einer Abstracten Eltern Klasse realisiert von der alle Klassen erben und dann habe ich die Elternklasse habe ich mit Traits versehen. So spart man sich gehörig schreibarbeit. lgmb