[Erledigt] Klasse aus einer anderen Klasse aufrufen

[Gast]

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

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

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

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

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

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

[ChrisB]

Ich werf' mal Dependency Injection in den Raum.

[ragtek]

http://www.php.de/520669-post15.html

[Gast]

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

[litterauspirna]

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

[ragtek]

Was hoffst du eigentlich mit

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

[Gast]

Was hoffst du eigentlich mit

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

[nikosch]

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

[MOD: Thread geschlossen]