Referenz auf "Eltern"-Klasseninstanz

[Sebastian Suchanek]

Hallo NG!

Gegeben sei folgende - stark vereinfachte - Konstellation:

---------------------------- 8< ----------------------------

<?php
class ClassA {
[...]
}

class ClassB {
public function construct__ () {
$this->myClassA = new ClassA();
}
}

$myClassB = new ClassB();
?>

---------------------------- 8< ----------------------------

Kann ich halbwegs elegant von der Instanz "myClassA" aus
irgendwie Methoden der "Eltern"-Instanz "myClassB"
(nicht der Klasse "ClassB"!) aufrufen? (Und wenn ja, wie?) Oder
muss ich mir hier irgendwelche Pointer- bzw. Handler-Konstrukte
basteln, die ich beim Aufrufen des Konstruktors von ClassA
übergeben und dann in einer Variable von ClassA bzw. myClassA
speichern muss?


TIA,

Sebastian

[Stefan Froehlich]

On Sat, 01 Jul 2023 21:27:13 Sebastian Suchanek wrote:
> ---------------------------- 8< ----------------------------
>
> <?php
> class ClassA {
> [...]
> }
>
> class ClassB {
> public function construct__ () {
> $this->myClassA = new ClassA();
> }
> }
>
> $myClassB = new ClassB();
> ?>
>
> ---------------------------- 8< ----------------------------
>
> Kann ich halbwegs elegant von der Instanz "myClassA" aus
> irgendwie Methoden der "Eltern"-Instanz "myClassB"
> (nicht der Klasse "ClassB"!) aufrufen?

Nein, natürlich nicht. myClassA könnte ja auch in myClassC oder
völlig eigenständig verwendet werden - von innerhalb des Objekt ist
das nicht feststellbar.

> Oder muss ich mir hier irgendwelche Pointer- bzw.
> Handler-Konstrukte basteln, die ich beim Aufrufen des Konstruktors
> von ClassA übergeben und dann in einer Variable von ClassA bzw.
> myClassA speichern muss?

Das wäre eine Möglichkeit.

Alternativ böte sich auch noch an, das Objektmodell auf seine
Eignung für den gegebenen Sachverhalt zu überprüfen. Ohne nähere
Informationen maße ich mir da kein Urteil an, aber es besteht
zumindestens ein Anfangsverdacht, dass sich das auch schöner lösen
lassen sollte.

Servus,
Stefan

--
http://kontaktinser.at/ - die kostenlose Kontaktboerse fuer Oesterreich
Offizieller Erstbesucher(TM) von mmeike

Stefan. Für neue Eumel in wichtigen Welten!
(Sloganizer)

[Arno Welzel]

Sebastian Suchanek, 2023-07-01 21:27:

> Gegeben sei folgende - stark vereinfachte - Konstellation:
>
> ---------------------------- 8< ----------------------------
>
> <?php
> class ClassA {
> [...]
> }
>
> class ClassB {
> public function construct__ () {
> $this->myClassA = new ClassA();
> }
> }
>
> $myClassB = new ClassB();
> ?>
>
> ---------------------------- 8< ----------------------------
>
> Kann ich halbwegs elegant von der Instanz "myClassA" aus
> irgendwie Methoden der "Eltern"-Instanz "myClassB"

Das ist *keine* "Eltern"-Instanz! ClassA wird einfach nur als *Member*
von ClassB erzeugt.

Wenn Du ClassA als "Eltern"-Instanz haben willst, wäre das sowas:

class ClassA
{
}

class ClassB extends ClassA
{
}

Siehe auch:

<https://www.php.net/manual/de/language.oop5.inheritance.php>

> (nicht der Klasse "ClassB"!) aufrufen? (Und wenn ja, wie?) Oder
> muss ich mir hier irgendwelche Pointer- bzw. Handler-Konstrukte
> basteln, die ich beim Aufrufen des Konstruktors von ClassA
> übergeben und dann in einer Variable von ClassA bzw. myClassA
> speichern muss?

Es sind keine "Pointer-Konstrukte" sondern einfach nur die übliche
Schreibweise, wenn man auf Member zugreift:

$this->myClassA->methodeVonClassA();


--
Arno Welzel
https://arnowelzel.de

[Stefan Froehlich]

On Mon, 03 Jul 2023 02:35:26 Arno Welzel wrote:
> Sebastian Suchanek, 2023-07-01 21:27:
>> Gegeben sei folgende - stark vereinfachte - Konstellation:
>>
>> ---------------------------- 8< ----------------------------
>>
>> <?php
>> class ClassA {
>> [...]
>> }
>>
>> class ClassB {
>> public function construct__ () {
>> $this->myClassA = new ClassA();
>> }
>> }
>>
>> $myClassB = new ClassB();
>> ?>
>>
>> ---------------------------- 8< ----------------------------
>>
>> Kann ich halbwegs elegant von der Instanz "myClassA" aus
>> irgendwie Methoden der "Eltern"-Instanz "myClassB"
>
> Das ist *keine* "Eltern"-Instanz! ClassA wird einfach nur als *Member*
> von ClassB erzeugt.
>
> Wenn Du ClassA als "Eltern"-Instanz haben willst, wäre das sowas:
>
> class ClassA
> {
> }
>
> class ClassB extends ClassA
> {
> }

Auch das wäre keine Eltern*instanz*, sondern eine Eltern*klasse*.

Sebastian möchte offensichtlich aus einem Objekt B heraus auf das
Objekt A zugreifen, in dem B als Instanzvariable enthalten ist. Man
könnte A schon mit Bauchweh als "Elterninstanz" bezeichnen, bloß tut
das keiner, weil sie für B (aus gutem Grund) nicht sichtbar ist.

Servus,
Stefan

--
http://kontaktinser.at/ - die kostenlose Kontaktboerse fuer Oesterreich
Offizieller Erstbesucher(TM) von mmeike

Spaß mit Stefan, standhaft und scheu!
(Sloganizer)

[Arno Welzel]

Stefan Froehlich, 2023-07-03 09:23:

> On Mon, 03 Jul 2023 02:35:26 Arno Welzel wrote:
>> Sebastian Suchanek, 2023-07-01 21:27:
>>> Gegeben sei folgende - stark vereinfachte - Konstellation:
>>>
>>> ---------------------------- 8< ----------------------------
>>>
>>> <?php
>>> class ClassA {
>>> [...]
>>> }
>>>
>>> class ClassB {
>>> public function construct__ () {
>>> $this->myClassA = new ClassA();
>>> }
>>> }
>>>
>>> $myClassB = new ClassB();
>>> ?>
>>>
>>> ---------------------------- 8< ----------------------------
>>>
>>> Kann ich halbwegs elegant von der Instanz "myClassA" aus
>>> irgendwie Methoden der "Eltern"-Instanz "myClassB"
>>
>> Das ist *keine* "Eltern"-Instanz! ClassA wird einfach nur als *Member*
>> von ClassB erzeugt.
>>
>> Wenn Du ClassA als "Eltern"-Instanz haben willst, wäre das sowas:
>>
>> class ClassA
>> {
>> }
>>
>> class ClassB extends ClassA
>> {
>> }
>
> Auch das wäre keine Eltern*instanz*, sondern eine Eltern*klasse*.

Ja, weil es nur sowas gibt. Eine Instanz kann nicht ein "Kind" haben,
sondern nur Member.

> Sebastian möchte offensichtlich aus einem Objekt B heraus auf das
> Objekt A zugreifen, in dem B als Instanzvariable enthalten ist. Man
> könnte A schon mit Bauchweh als "Elterninstanz" bezeichnen, bloß tut
> das keiner, weil sie für B (aus gutem Grund) nicht sichtbar ist.

Eben.