Instanz an Unterklasse weiterreichen?

[Forumsgast]

Hallo,

ich hab eine "Hauptklasse" (core.class.php) und eine "Unterklasse" (subcore.class.php).
Ich weise im Konstruktur der "Hauptklasse" einer Variable ($strContent) einen Wert zu und will diesen Wert mit einer Methode der "Unterklasse" ausgeben.

Hier mal der Beispiel-Code: (Zum Problem komm ich nach dem Code...)
index.php

<?php
    include('core.class.php');
    include('subcore.class.php');
    
    $core = new core();
    $subcore = new subcore();
    
    echo $subcore->getContent();
?>

core.class.php

<?php
class core
{
    protected $strContent = NULL;
    
    function __construct()
    {
        $this->strContent = 'Führe aus<br />';
    }
}
?>

subcore.class.php

<?php
class subcore extends core
{
    function __construct()
    {
        parent::__construct();
    }

    public function getContent()
    {
        return $this->strContent;
    }
}
?>

Also, um Zugriff aus der "Unterklasse" auf die Variable "$strContent" aus der "Hauptklasse" zu haben, muss ich im Konstruktor der "Unterklasse" ein

parent::__construct(); 

einfügen.

So jetzt zum Problem!
Nehmen wir mal an, das Projekt ist sehr groß und der Konstruktor der "Hauptklasse" übernimmt Aufgaben wie:
- Verbindung mit der MySQL-Datenbank
- Liest Konfig-Dateien ein
- usw.

Jetzt brauch ich aber auch eine MySQL-Verbindung in der "Unterklasse" und würde gern die Verbindung nehmen die mit dem Konstruktor der "Hauptklasse" erstellt wurde.
Das Problem ist, das durch

parent::__construct(); 

der Konstruktor der "Hauptklasse" 2x mal aufgerufen wird, und 2 mal eine MySQL-Verbindung hergestellt wird. Was natürlich aus Performance-Gründen unakzeptabel ist, vorallem wenns es noch 10 weitere "Unterklassen" gibt.

Ich dachte mir, setzt du in der "Hauptklasse" im Konstruktor einfach eine If-Abfrage ob die Variable schon ein Wert zugewiesen wurde, und wenn ja, dann mach nix und weis es eben nicht nochmal zu.
Aber leider geht, das auch nicht, da der Konstruktor der Hauptklasse nach dem parent::__construct(); scheinbar die Variable nicht kennt.

Also, kennt jemand eine Möglichkeit, die Instanz aus der "Hauptklasse" an die "Unterklasse" weiterzureichen, ohne jedes mal den Konstruktor der "Hauptklasse" wieder aufrufen zu müssen?

Danke!

[Forumsgast]

Also, kennt jemand eine Möglichkeit, die Instanz aus der "Hauptklasse" an die "Unterklasse" weiterzureichen, ohne jedes mal den Konstruktor der "Hauptklasse" wieder aufrufen zu müssen?

so wie du es machen willst, müsstest du die variablen statisch ansprechen.

so ganz verstehe ich nicht, was die klasse core denn soll. alles was du beschreibst sind singletone aufgaben, weswegen ich gemäß diesem beispiel die klasse core als singleton anlegen würde und allen kindern im konstruktor die instanz des cores geben würde....

[Forumsgast]

Static wird hier nicht gehen! Da ich, z.B. das Handle der MySQL-Verbindung an die anderen übergeordneten Klassen weiter geben will, und die Verbindung im Konstruktor der Hauptklasse erstellt wird. Und der static-variable kann ich das handle da ja schlecht zu weisen.

In der Hauptklasse, befinden sich u.a. alle möglichen Funktionen die ich immer wieder brauche!

[Forumsgast]

Aber leider geht, das auch nicht, da der Konstruktor der Hauptklasse nach dem parent::__construct(); scheinbar die Variable nicht kennt.

Wieso sollte das nicht gehen ?

<?

class main 
  {
  public $conn;
  
  function __construct ()
    {
    if (empty ($this->conn)) $this->conn++;
    }

  function getConn ()
    {
    echo $this->conn;
    }
  }
  
class sub extends main
  {
  function __construct ()
    {
    parent::__construct ();
    }
  }

$m = new main ();
$m->getConn (); // 1
$s = new sub ();
$s->getConn (); // 1

[Forumsgast]

Siehe unter mir! geht doch nicht!

[Forumsgast]

Falsch!!!
Erklär mir das mal???
Warum wird "echo 'Aufruf';" 2x ausgegeben?

Das 1 raus kommt ist ja klar, weil die Variable ja immer wieder mit 0 gestartet wird.
Also es geht doch nicht!

<?php

class main
  {
  public $conn;

  function __construct ()
    {
    if (empty ($this->conn))
    {
        $this->conn++;
        echo 'Aufruf<br>';
    }
    }

  function getConn ()
    {
    echo $this->conn;
    }
  }

class sub extends main
  {
  function __construct ()
    {
    parent::__construct ();
    }
  }

$m = new main ();
$s = new sub ();
$s->getConn (); // 1

?>

[Forumsgast]

Falsch!!!
Erklär mir das mal???
Warum wird "echo 'Aufruf';" 2x ausgegeben?

Das 1 raus kommt ist ja klar, weil die Variable ja immer wieder mit 0 gestartet wird.
Also es geht doch nicht!

tut doch das was es soll? hä?

[Forumsgast]

Nein, tut es nicht!

Denn die Ausgabe "Aufruf" wird 2 mal ausgegeben. Das heißt der Konstruktor der Hauptklasse wurde 2 mal ausgeführt - und die Variable $conn die um 1 hochgezählt wurde, hat nach dem 2 Konstruktoraufruf, keinen Wert!

Also ist

if (empty ($this->conn))
{
...
} 

sinnlos, weil der Wert $conn des ersten Konstruktor-Aufrufes im zweiten Aufruf nicht mehr da ist, bzw. nicht erkannt wird. Deshalb wird auch zweimal das echo ausgegeben. Wenn dann soll es aber nur einmal ausgegeben werden.

Verstehst du?

[Forumsgast]

Singleton wurde doch schon genannt?!

[Forumsgast]

Ach so, ja nee. extends erweitert ja nur die Klasse, kein bestehendes Objekt. Wie auch, schließlich könnten ja auch 2 main Objekte bestehen, welches sollte es zu sub erweitern... Demzufolge ist $conn stets neu intialisiert...

Und der static-variable kann ich das handle da ja schlecht zu weisen.

Doch. Du mußt dann nur den Klassennamen statt parent verwenden.

<?

class main 
  {
  public static $conn;
  
  function __construct ()
    {
    if (empty (self::$conn)) 
      {
      echo '*' ; 
      self::$conn++; 
      };
    }

  function getConn ()
    {
    echo self::$conn;
    }
  }
  
class sub extends main
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo main::$conn;
    }
  }

$m = new main ();
$m->getConn ();  
$s = new sub ();
$s->getConn ();

*11

[Forumsgast]

Ach so, ja nee. extends erweitert ja nur die Klasse, kein bestehendes Objekt. Wie auch, schließlich könnten ja auch 2 main Objekte bestehen, welches sollte es zu sub erweitern... Demzufolge ist $conn stets neu intialisiert...


Doch. Du mußt dann nur den Klassennamen statt parent verwenden.

<?

class main 
  {
  public static $conn;
  
  function __construct ()
    {
    if (empty (self::$conn)) 
      {
      echo '*' ; 
      self::$conn++; 
      };
    }

  function getConn ()
    {
    echo self::$conn;
    }
  }
  
class sub extends main
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo main::$conn;
    }
  }

$m = new main ();
$m->getConn ();  
$s = new sub ();
$s->getConn ();

*11

nimm parent::$conn

ps.: $conn ist ein schlimmer variablen name. nimm $connection, nach $conn frag ich mich immer wies weitergeht....

[Forumsgast]

nimm parent::$conn

Nicht wenn ich sub weiter ableiten möchte! Habe das schon bewußt gemacht.

ps.: $conn ist ein schlimmer variablen name. nimm $connection, nach $conn frag ich mich immer wies weitergeht....

Bestimmt nicht "tainer"! Ist doch nur ein Beispiel. Eine Connection wird man wohl schwerlich inkrementieren. "main" und "sub" sind auch schlechte Bezeichner.

[Forumsgast]

Nicht wenn ich sub weiter ableiten möchte! Habe das schon bewußt gemacht.

wenn ich das weiter ableiten möchte, sollte ich immer auch parent::__construct() aufrufen, da ich mir ansonsten ins bein schieße...

<?

class main 
  {
  public static $conn;
  
  function __construct ()
    {
    if (empty (self::$conn)) 
      {
      echo '*' ; 
      self::$conn++; 
      };
    }

  function getConn ()
    {
    echo self::$conn;
    }
  }
  
class sub extends main
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo parent::$conn;
    }
  }

class subsub extends sub
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo parent::$conn;
    }
  }

class subsubsub extends subsub
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo  parent::$conn;
    }
  }


class subsubsubsub extends subsubsub
  {
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo parent::$conn;
    }
  }


$m = new main ();
$m->getConn ();  
$s = new subsubsubsub ();
$s->getConn ();

Bestimmt nicht "tainer"! Ist doch nur ein Beispiel. Eine Connection wird man wohl schwerlich inkrementieren. "main" und "sub" sind auch schlechte Bezeichner.

was zur hölle ist tainer? ich mag es einfach nicht, so etwas schönes wie connection abzukürzen....gut, ich mag generell auch sonst keine abkürzungen...

[Forumsgast]

wenn ich das weiter ableiten möchte, sollte ich immer auch parent::__construct() aufrufen, da ich mir ansonsten ins bein schieße...

Kein Mensch redet hier von __construct(). Wenn Du in meinen Code guckst, wirst Du sehen, dass ich über main:: nur die statische Variable angesprochen habe, die nunmal nur für main definitiv existiert.

Zugegeben etwas konstruiert, aber hier der Unterschied:

<?

class main 
  {
  public static $conn;
  
  function __construct ()
    {
    if (empty (self::$conn)) 
      {
      echo '*' ; 
      self::$conn++; 
      };
    }

  function getConn ()
    {
    echo self::$conn;
    }
  }
  
class sub extends main
  {
  static $conn = 23;

  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo parent::$conn;
    }
  }

class subsub extends sub
  {
  
  function __construct ()
    {
    parent::__construct ();
    }

  function getConn ()
    {
    echo parent::$conn;
    echo main::$conn;
    }
  }



$m = new main (); 
$m->getConn ();   // *1
$s = new subsub ();
$s->getConn ();  // 23 1

[Forumsgast]

Kein Mensch redet hier von __construct(). Wenn Du in meinen Code guckst, wirst Du sehen, dass ich über main:: nur die statische Variable angesprochen habe, die nunmal nur für main definitiv existiert.

sie existiert eben immer für jedes child.