Objekt einer Klasse in anderer Klasse nutzen

[dedlfix]

echo $begrüßung;

Hier kann es sinnvoll sein, eine Referenz des erzeugten Objekts statt einer Kopie davon zu speichern. Das kommt hauptsächlich drauf an, ob mit weiteren Referenzen im Konstruktor gearbeitet wird.

in diesen Part verstehe ich noch nicht ganz warum es sinnvoll sein kann eine Referenz eines Objektes statt einer Kopie zu speichern, in den Konstrukter der Datenbankklasse stelle ich die Verbindung zur DB her. Es werden keine Referenzen benutzt.

Einen Grund hat Christian schon genannt. Der ist jedoch unter PHP nur bei großen Datenstrukturen relevant. Siehe dazu den eingerückten Abschnitt "Note: There is no performance loss ..." im Handbuchkapitel References inside the constructor.

Ansonsten beschäftigt sich die verlinkte Handbuchseite mit dem Hauptgrund, mit einer Referenz auf das erzeugte Objekt statt einer kopie zu arbeiten. Zugegeben, dieser Stoff ist recht schwer zu verstehen, vielleicht ist folgendes Beispiel einfacher:

  
class ElementsCollection {  
  function &getElements() {  
    static $elements = array();  
    return $elements;  
  }  
  
  function addElement($id, &$element) {  
    $elements =& ElementsCollection::getElements();  
    $elements[$id] =& $element; // *3  
  }  
}  
  
class Element {  
  
  var $id;  
  var $content = 'Default-Wert';  
  var $children = array();  
  
  function Element($id) { // Element-Constructor  
    $this->id = $id;  
    ElementsCollection::addElement($id, $this); // *2  
  }  
  
  function &addChild($id) {  
    return $this->children[$id] = new Element($id);  // *5  
    // return $this->children[$id] =& new Element($id);  // *8  
  }  
}  
  
$parent =& new Element('foo');  // *1  
$child =& $parent->addChild('bar'); // *4  
$child->content = 'neuer Wert'; // *6  
  
echo '<pre>';  
print_r(ElementsCollection::getElements());  

Ausgabe:

Array (
  [foo] => element Object (
    [id] => foo
    [content] => Default-Wert
    [children] => Array (
      [bar] => element Object (
        [id] => bar
        [content] => neuer Wert
        [children] => Array ()
      )
    )
  )

[bar] => element Object (
    [id] => bar
    [content] => Default-Wert  // *7
    [children] => Array ()
  )

*1 Es wird ein $parent-Objekt der Klasse Element mit der ID 'foo' erstellt.
*2 Das Element fügt sich im Constructor selbst in die ElementsCollection ein.
(Die ElementsCollection ist eine Klasse, deren Methoden nur statisch aufgerufen werden. Es existiert kein Objekt dieser Klasse. Dadurch wird sichergestellt, dass es die Kollektion der Elemente nur einmal gibt. Aufgabe der ElementsCollection ist, auf alle Elemente direkt zugreifen zu können, egal wie tief die Verschachtelung geht.)
*3 Die ElementsCollection speichert eine Referenz auf das 'foo'-Objekt.
*4 Nun wird ein neues Kind-Element mit der ID 'bar' zu $parent hinzugefügt.
*5 Durch Aufruf des Konstruktors (new Element) wird das neu erzeugte 'bar'-Element zur ElementsCollection hinzugefügt. Allerdings wird nur eine Kopie des 'bar'-Elements im children-Array von 'foo' abgelegt.
Außerdem soll addChild() auch eine Referenz auf das eben erstellte Element zurückgeben. (Momentan liefert es nur eine Referenz auf eine Kopie zurück.)
*6 Der Wert von content des 'bar'-childs soll geändert werden.
*7 Da hier allerdings nur noch eine Kopie auf das eigentlich unter *5 mit new angelegte Element vorliegt, wird der direkte Eintrag von 'bar' in der ElementsCollection nicht geändert.
*8 Wird diese Zeile statt der *5 verwendet, bleibt die Beziehung zwischen $child und dem 'bar' in der ElementsCollection erhalten.

echo "$verabschiedung $name";

P.S. Da dieses Beispiel eine Konzeptionsschwäche enthält, die beim Versuch einzelne Elemente zu löschen auffällt, ist es mehr zur Veranschaulichung der Referenzproblematik und als zu einem praktischen Einsatz geeignet.