Ankündigung

Einklappen
Keine Ankündigung bisher.

[Erledigt] Klasse aus einer anderen Klasse aufrufen

Einklappen

Neue Werbung 2019

Einklappen
Dieses Thema ist geschlossen.
X
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • [Erledigt] Klasse aus einer anderen Klasse aufrufen

    Hallo Leute,

    habe mich in letzter Zeit mal damit beschäftigt wie man sinnvoll eine Klasse aus einer anderen Klasse aufrufen könnte und bin dabei auf mehrere Möglichkeiten gekommen, die zwar meistens funktionieren, aber nicht immer meinen Bedürfnissen entsprachen.

    Hier mal die Methoden die ich gefunden habe:

    1. Klassen statisch verwenden
    PHP-Code:
    class Foo {
        public function 
    foo() {}
    }

    class 
    Bar {
        public function 
    foo() {
            
    Foo::foo();
        }

    Der Nachteil hierbei ist das man keine Werte in den statischen Klassen speichern kann (außer natürlich statisch, was aber auch nicht immer sinnvoll ist)


    2. Singleton
    PHP-Code:
    class Foo {
        protected 
    $instance null;
        private function 
    __construct() {}
        private function 
    __clone() {}
        public function 
    getInstance() {
            if (
    null === self::$instance) {
                
    self::$instance = new self;
            }
            return 
    self::$instance;
        }
        public function 
    foo() {}
    }

    class 
    Bar {
        public function 
    foo() {
            
    $foo Foo::getInstance();
            
    $foo->foo();
        }

    Im Gegensatz zu der statischen Methode finde ich diese Methode schon besser und in bestimmten Fällen auch sehr hilfreich (z.B. Datenbank-Klasse, FTP-Klasse, Mail-Klasse, ....). Aber wenn man diese Klasse mehrmals instanzieren muss und nicht nur einmal, auch wieder unbrauchbar.


    3. Instanz übergeben
    PHP-Code:
    class Foo {
        public function 
    foo() {}
    }

    class 
    Bar {
        public function 
    __construct($foo) {
            
    $this->foo $foo;
        }
        public function 
    foo() {
            
    $this->foo->foo();
        }

    Diese Methode würde zwar funktionieren, ist aber nicht ganz so flexibel und unsauber.


    4. Globalisieren der Instanz
    PHP-Code:
    class Foo {
        public function 
    foo() {}
    }

    $foo = new Foo;

    class 
    Bar {
        public function 
    foo() {
            global 
    $foo;
            
    $foo->foo();
        }

    Wahrscheinlich die schlimmste Methode, da dass dann gar nicht mehr flexibel ist und auch unsauber ist.


    5. Vererbung der Klasse
    PHP-Code:
    class Foo {
        public function 
    foo() {}
    }

    class 
    Bar extends Foo {
        public function 
    foo() {
            
    $this->foo();
        }

    Diese Methode ist in bestimmten Fällen auch ganz hilfreich. Aber bei mehreren Klassen, die man in einer Klasse braucht auch schon wieder unbrauchbar.


    Jetzt bleibt mir nur die Frage, welche Methode denn am flexibelsten und schönsten wäre. Ich persönlich finde die Singleton-Methode ganz nett, da ich meisten Klassen habe, die nur einmalig instanziert werden müssen, und ich ab und zu mehrere Klassen in einer anderen benötige. Wobei das auch unübersichtlich wird, wenn man in einer Klasse z.B. 5 anderen Klassen per Singleton aufruft.

    Wie macht ihr das und würdet ihr Singleton und die anderen Methoden empfehlen?

    Freue mich auf eure Ideen, Anmerkungen und Lösungen.
    mfg Tobias


  • #2
    Ich werf' mal Dependency Injection in den Raum.

    Kommentar


    • #3
      http://www.php.de/520669-post15.html

      Kommentar


      • #4
        So habe mal ein wenig zu Dependency Injection durchgelesen, davon verstehe ich zwar grad noch nicht so viel, aber ich lese es mir einfach nochmal durch und schaue mir Code-Beispiele an (kennt ihr da vielleicht ein paar gute?).

        Zu dem anderen Post (http://www.php.de/520669-post15.html):
        Die erste Möglichkeit habe ich ja auch schon oben geschrieben.
        Die zweite Möglichkeit auch schon halb, wobei IMHO das instanzieren der Klasse meistens nur Performance frisst.
        Die dritte Möglichkeit wäre vielleicht noch eine Idee, die ich mir auch nochmal anschauen werde.

        mfg Tobby

        Kommentar


        • #5
          Via Type Hint kannst du es auch umsetzen. Da übergibst du den Namen der Klasse und das Objekt bzw. die Objekt Variable einer Methode.

          Gruß litter
          Aus dem Dynamo Lande kommen wir. Trinken immer reichlich kühles Bier. Und dann sind wir alle voll, die Stimmung ist so toll. Aus dem Dynamo Lande kommen wir.
          http://www.lit-web.de

          Kommentar


          • #6
            Was hoffst du eigentlich mit
            PHP-Code:
            class Foo {
                public function 
            foo() {}
            }

            class 
            Bar extends Foo {
                public function 
            foo() {
                    
            $this->foo();
                }

            IMHO endet das mit nem Fehler da du da eine Endlosschleife produziert hast (sorry falls es nicht so ist, hab gerade keine Umgebung um es zu testen)
            Du meinst wohl parent::foo

            Kommentar


            • #7
              Zitat von ragtek Beitrag anzeigen
              Was hoffst du eigentlich mit
              PHP-Code:
              class Foo {
                  public function 
              foo() {}
              }

              class 
              Bar extends Foo {
                  public function 
              foo() {
                      
              $this->foo();
                  }

              IMHO endet das mit nem Fehler da du da eine Endlosschleife produziert hast (sorry falls es nicht so ist, hab gerade keine Umgebung um es zu testen)
              Du meinst wohl parent::foo
              Ja, du hast recht, waren wohl mehrere Flüchtigkeitsfehler auf einmal

              Habe jetzt einen ganz netten Artikel über Dependency Injection gefunden, falls es noch jemanden interessiert: What is Dependency Injection? - Fabien Potencier

              mfg Tobby

              Kommentar


              • #8
                Mit Verweis auf: http://www.php.de/520669-post15.html

                [MOD: Thread geschlossen]
                --

                „Emoticons machen einen Beitrag etwas freundlicher. Deine wirken zwar fachlich richtig sein, aber meist ziemlich uninteressant.
                Wenn man nur Text sieht, haben viele junge Entwickler keine interesse, diese stumpfen Texte zu lesen.“


                --

                Kommentar

                Lädt...
                X