Speicherverwaltung von PHP bei OOP

[Jens Hopp]

Hallo.

Vor einigen Tagen ist mir hier schon gut geholfen worden, daher traue ich mich nochmal ;-)

Meine Frage ist zum Thema, wie PHP bei objektorientierter Programmierung den Speicher verwaltet.

Ich denke, es ist klar, daß jede neue Instanz einer Klasse Arbeitsspeicher verbraucht, um ihre Variablen unterzubringen. Logisch.
Aber:
GILT DAS AUCH FÜR DIE -> METHODEN <-, die in einer Klasse definiert sind?
Denn die sind ja eigentlich in jeder Instanz genau gleich. Da könnte man ja meinen, daß PHP die nur einmal im Speicher ablegt und bei Bedarf darauf zugreift.
Oder wird auch jede Methode in jeder neuen Instanz eines Objektes neu im Speicher abgelegt.
Denn dann kann ja der Speicherbedarf schnell anwachsen, noch dazu, wenn man viel mit Vererbung arbeitet.

Sollte es wirklich so sein, daß die Methoden auch immer wieder neu "erzeugt" werden, habe ich mir dieses kleine Testscript ausgedacht, welches die Methoden einer Klasse in ein speziell dafür NUR EINMAL erzeugtes Objekt auslagert (siehe unten).

Kann mir jemand helfen und mir sagen, wie es wirklich ist?
Und ob meine unten gezeigte Konzeption in die richtige Richtung weist?

Oder ist alles ein großer Denkfehler?

Danke und viele Grüße
Jens Hopp

<schnipp>-------------------------------------------------

<pre>
<?

//eine Klasse definieren:
class parent_class {
 function parent_class(){
  $this->fritz = 'fritz';
  $this->hans = 'hans';
 }
}

//dazu eine Klasse definieren, die Methoden enthält...
class parent_class_methods {
 function change_fritz(&$obj,$prm=array()){
  $obj->fritz = 'fritz_geändert';
 }

function define_klaus(&$obj,$prm){
  $obj->klaus = $prm;
 }
}
//und GENAU EINE instanz erzeugen:
$parent_class_methods = new parent_class_methods();
//alle methoden erhalten als ersten Parameter eine Referenz auf das zu bearbeitende Objekt,
//da ja mit $this nicht direkt darauf zugegriffen werden kann
//(mit $this könnte man vielmehr direkt andere methoden dieser klasse erreichen)

//das gleiche für zwei weitere methoden-klassen, die von dieser erben:
class klasse_a_methods extends parent_class_methods{
 function change_edward(&$obj,$prm){
  $obj->edward = 'edward_geändert';
 }

function define_lothar(&$obj,$prm){
  $obj->lothar = $prm;
 }
}
$klasse_a_methods = new klasse_a_methods();

class klasse_b_methods extends parent_class_methods{
 function change_albert(&$obj,$prm=array()){
  $obj->albert = 'albert_geändert';
 }

function define_gerhard(&$obj,$prm){
  $obj->gerhard = $prm;
 }
}
$klasse_b_methods = new klasse_b_methods();

//die Klassen klasse_a und klasse_b erben von parent_class
//Sie beinhalten Referenzen auf die gleichnamigen methoden-klassen,
//damit ich auch innerhalb eines objektes direkt auf die methoden zugreifen kann
class klasse_a extends parent_class {
 function klasse_a(){
  $this->parent_class();
  global $klasse_a_methods;
  $this->method = &$klasse_a_methods; //Referenz auf methoden-klasse
  $this->lothar = 'lothar';
  $this->edward = 'edward';
 }
}

class klasse_b extends parent_class {
 function klasse_b(){
  $this->parent_class();
  global $klasse_b_methods;
  $this->method = &$klasse_b_methods; //Referenz auf methoden-klasse
  $this->albert = 'albert';
  $this->gerhard = 'gerhard';
 }
}

//und jetzt kann man munter instanzen von klasse_a und klasse_b erzeugen.
//über ->method verweisen diese immer auf das jeweils gleiche objekt, welches die methoden beinhaltet
//und das spart speicher (könnte zumindest so sein ;-)
$objekt_1 = new klasse_b();
echo $objekt_1->fritz."\n";
$objekt_1->method->change_fritz(&$objekt_1);
echo $objekt_1->fritz."\n";
$objekt_1->method->define_klaus(&$objekt_1,'du bist klaus');
echo $objekt_1->klaus."\n";

$objekt_2 = new klasse_a();
echo $objekt_2->fritz."\n";
$objekt_2->method->define_lothar(&$objekt_2,'du bist lothar');
echo $objekt_2->lothar."\n";

$objekt_1->method->change_albert(&$objekt_1);
echo $objekt_1->albert."\n"

?>
</pre>