• Jetzt anmelden. Es dauert nur 2 Minuten und ist kostenlos!

Singleton vs komplett statische Klasse

Anusha

Mitglied
Hi,

ich fange grade an mich intensiver mit Design Patterns auseinanderzusetzen.
Laut meinem Buch das ich grade lese wird empfohlen zum Beispiel ne Config Klasse als Singleton zu implementieren.

Mir stellt sich jetzt die Frage was der Unterschied dazu ist in dem Fall ne komplett statische Klasse zu erstellen...
Hat irgendwas davon Vorteile/Nachteile die mir jetzt nich einleuchten?
 
Werbung:
Ich würde sagen das Entscheidende ist, dass eine Singleton Klasse Interfaces implementieren kann. Eine statische Klasse kann das nicht.
 
Erklärung dazu steht hier: Singleton - php bar
Nachteile: Singleton (Entwurfsmuster)

Vergiss bitte bei der ganzen OOP nicht, dass es nicht für den Einsatz von Webseiten konzipiert wurde.
Ein Script in PHP zum Beispiel lebt nur solange wie die max_execution_time in der PHP-Ini es zulässt. Das heisst im Normalfall 30 Sekunden.
Nach dem Absenden der Seite ist es auch schon vorbei, alles wird gelöscht. Bei Aufruf einer PHP-Seite wird alles erst mal erstellt, weshalb OOP auch einen gewaltigen Oberhead mit sich bringt und oft langsamer ist als prozedurale Programmierung in PHP wohlgemerkt.

Dies sieht bei Programmen die mit C++ programmiert sind, ganz anders aus und ist auch nicht miteinander zu vergleichen.

Wollte ich nur mal erwähnt haben, da ich nicht weiss was in deinem Buch steht.
 
Werbung:
Darf man Fragen, ab wann es dir sinnvoll erscheint Objektorientiert in PHP zu programmieren?
Das Benutzen von Datenbank/Formularklassen sollte ja eigentlich kein Problem mit sich bringen.

Allerdings hab ich noch nie Vererbung etc. in meinen Webanwendungen gebraucht. In welchen Szenarien bietet sich so etwas an?
Irgendwie muss man den Zustand eines Objekts ja auf die "naechste" Seite mitnehmen.
Gibts da noch andere moeglichkeiten als serialize und in ner Session speichern?
 
Darf man Fragen, ab wann es dir sinnvoll erscheint Objektorientiert in PHP zu programmieren?

Da fragst du ja was?
Es gibt da 2 Lager und die streiten sich ob es sinnvoll ist OOP in PHP einzusetzen oder nicht.
Ich will da niemandem seine Vorgehensweise vorschreiben und halte mich da lieber raus. Das führt zu nichts.

Irgendwie muss man den Zustand eines Objekts ja auf die "naechste" Seite mitnehmen.
Auf die 2. Seite nimmst du gar nichts mit.
Es wird eine PHP seite aufgerufen. Der Code von der Seite wird vom Parser interpretiert. Es wird die Seite nach dem alles abgearbeitet wurde abgeschickt an den Client und das wars. Alles was im Speicher war wird durch den Carbage Collector gelöscht.

Beim nächsten Aufruf einer neuen Seite beginnt das Spiel von vorn.
 
Singletons sind getarnte globale Variablen. Statische Methoden sind prinzipiell auch nicht viel besser. Beides sollte vermieden werden.

Patrick Leuppert schrieb:
Ich würde sagen das Entscheidende ist, dass eine Singleton Klasse Interfaces implementieren kann. Eine statische Klasse kann das nicht.

Sicher?

Anusha schrieb:
Allerdings hab ich noch nie Vererbung etc. in meinen Webanwendungen gebraucht. In welchen Szenarien bietet sich so etwas an?

Wenn du eine Konkretisierung einer allgemeinen Klasse brauchst. In der Regel setzt man das ein, um gemeinsam nutzbaren Code zentral zu definieren oder um bestehende Klassen für einen bestimmten Einsatzzweck anzupassen (adaptieren).

Nimm beispielsweise eine Klasse Rechteck, die ein Rechteck symbolisiert. Davon könnte eine Klasse Quadrat erben, die im Grunde alles so macht wie ein Rechteck, die nur die Erweiterung enthält, dass Breite und Höhe identisch sein müssen. In der Quadrat-Klasse würdest du dann diejenigen Methoden überschreiben, die Höhe und Breite setzen, um dort prüfen zu können, dass beide Werte identisch sind.

So kannst du sehr einleuchtend modellieren, dass ein Quadrat ein Rechteck mit gleicher Kantenlänge ist. Das steht praktisch genauso im Code.

PHP:
<?php

interface Drawable
{
    public function draw($canvas);
}

class Rectangle implements Drawable
{
    protected $x;
    protected $y;
    protected $width;
    protected $height;
    protected $borderColor;

    public function __construct($x, $y, $width, $height,
            $borderColor = array(255, 255, 255))
    {
        $this->x = $x;
        $this->y = $y;
        $this->setDimensions($width, $height);
        $this->borderColor = $borderColor;
    }

    public function setDimensions($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

    public function draw($canvas)
    {
        list($r, $g, $b) = $this->borderColor;

        $color = imagecolorallocate($canvas, $r, $g, $b);
        imagerectangle($canvas, $this->x, $this->y,
                $this->x + $this->width, $this->y + $this->height, $color);
    }
}

class Square extends Rectangle
{
    public function setDimensions($width, $height)
    {
        if ($width !== $height) {
            throw new Exception('Width and height are not equal');
        }

        parent::setDimensions($width, $height);
    }
}

class Text implements Drawable
{
    protected $x;
    protected $y;
    protected $text;
    protected $font;

    public function __construct($x, $y, $text, $font = 'LinLibertine_R')
    {
        $this->x = $x;
        $this->y = $y;
        $this->text = $text;
        $this->font = $font;
    }

    public function draw($canvas)
    {
        $color = imagecolorallocate($canvas, 0, 255, 0);

        imagettftext($canvas, 12, 0, $this->x, $this->y, $color, $this->font, $this->text);
    }
}


class Scene
{
    protected $width;
    protected $height;
    protected $drawingObjects = array();

    public function __construct($width = 640, $height = 480)
    {
        $this->width = $width;
        $this->height = $height;
    }

    public function addDrawingObject(Drawable $do)
    {
        $this->drawingObjects[] = $do;
    }

    public function render()
    {
        $canvas = imagecreatetruecolor($this->width, $this->height);

        foreach ($this->drawingObjects as $do) {
            $do->draw($canvas);
        }

        return $canvas;
    }
}

// Set the enviroment variable for GD
putenv('GDFONTPATH=' . realpath('.'));


$scene = new Scene();
$scene->addDrawingObject(new Rectangle(50, 50, 200, 100));
$scene->addDrawingObject(new Square(250, 150, 200, 200, array(255, 0, 0)));

// Folgende Zeile funktioniert nur, wenn LinLibertine_R.ttf im selben
// Verzeichnis existiert
#$scene->addDrawingObject(new Text(100, 400, 'Hallo Welt!', 'LinLibertine_R'));

// Diese Zeile erzeugt einen Fehler, weil das Quadrat nicht quadratisch ist
#$scene->addDrawingObject(new Square(0, 0, 100, 200));

$canvas = $scene->render();


header('Content-Type: image/png');

imagepng($canvas);
 
Werbung:
Alles und immer Objektorientiert. Prozeduraler Code hat maximal etwas in CLI-Scripten zu suchen. Er lässt sich nämlich kaum vernünftig warten. Immer daran denken: die Cost-Of-Change ist entscheidend weil Wartung das teuerste an der Softwareentwicklung ist.
 
Zurück
Oben