Ist es möglich, statische Klassen in PHP zu erstellen (wie in C #)?

Ich möchte eine statische Klasse in PHP erstellen und sie sich wie in C # verhalten lassen

1. Der Konstruktor wird beim ersten Aufruf der Klasse automatisch aufgerufen
2. Keine Instanziierung erforderlich

So etwas ...

static class Hello {
    private static $greeting = 'Hello';

    private __construct() {
        $greeting .= ' There!';
    }

    public static greet(){
        echo $greeting;
    }
}

Hello::greet(); // Hello There!

Sie können statische Klassen in PHP haben, aber sie rufen den Konstruktor nicht automatisch auf (wenn Sie versuchen, ihn aufzurufen self::__construct(), wird eine Fehlermeldung angezeigt).

Daher müssten Sie eine initialize()Funktion erstellen und in jeder Methode aufrufen:

<?php

class Hello
{
    private static $greeting = 'Hello';
    private static $initialized = false;

    private static function initialize()
    {
        if (self::$initialized)
            return;

        self::$greeting .= ' There!';
        self::$initialized = true;
    }

    public static function greet()
    {
        self::initialize();
        echo self::$greeting;
    }
}

Hello::greet(); // Hello There!


?>

Zusätzlich zu Gregs Antwort würde ich empfehlen, den Konstruktor auf privat zu setzen, damit es unmöglich ist, die Klasse zu instanziieren.

Meiner bescheidenen Meinung nach ist dies ein vollständigeres Beispiel, das auf Gregs basiert:

<?php

class Hello
{
    /**
     * Construct won't be called inside this class and is uncallable from
     * the outside. This prevents instantiating this class.
     * This is by purpose, because we want a static class.
     */
    private function __construct() {}
    private static $greeting = 'Hello';
    private static $initialized = false;

    private static function initialize()
    {
        if (self::$initialized)
            return;

        self::$greeting .= ' There!';
        self::$initialized = true;
    }

    public static function greet()
    {
        self::initialize();
        echo self::$greeting;
    }
}

Hello::greet(); // Hello There!


?>

Sie können diese "statischen" ähnlichen Klassen haben. aber ich nehme an, dass etwas wirklich Wichtiges fehlt: In PHP haben Sie keinen App-Zyklus, so dass Sie in Ihrer gesamten Anwendung keine echte Statik (oder Singleton) erhalten ...

siehe Singleton in PHP

final Class B{

    static $staticVar;
    static function getA(){
        self::$staticVar = New A;
    }
}

Die Struktur von b wird als Singeton-Handler bezeichnet. Sie können dies auch in a tun

Class a{
    static $instance;
    static function getA(...){
        if(!isset(self::$staticVar)){
            self::$staticVar = New A(...);
        }
        return self::$staticVar;
    }
}

Dies ist die Singleton-Verwendung $a = a::getA(...);

Im Allgemeinen bevorzuge ich es, reguläre nicht statische Klassen zu schreiben und eine Factory-Klasse zu verwenden, um einzelne (sudostatische) Instanzen des Objekts zu instanziieren.

Auf diese Weise arbeiten Konstruktor und Destruktor wie gewohnt, und ich kann auf Wunsch zusätzliche nicht statische Instanzen erstellen (z. B. eine zweite DB-Verbindung).

Ich verwende dies die ganze Zeit und ist besonders nützlich, um benutzerdefinierte Sitzungshandler für DB-Speicher zu erstellen, da der Destruktor die Sitzung beim Beenden der Seite in die Datenbank überträgt.

Ein weiterer Vorteil ist, dass Sie die Reihenfolge, in der Sie Dinge aufrufen, ignorieren können, da alles bei Bedarf eingerichtet wird.

class Factory {
    static function &getDB ($construct_params = null)
    {
        static $instance;
        if( ! is_object($instance) )
        {
            include_once("clsDB.php");
            $instance = new clsDB($construct_params);   // constructor will be called
        }
        return $instance;
    }
}

Die DB-Klasse ...

class clsDB {

    $regular_public_variables = "whatever";

    function __construct($construct_params) {...}
    function __destruct() {...}

    function getvar() { return $this->regular_public_variables; }
}

Überall, wo Sie es verwenden möchten, rufen Sie einfach an ...

$static_instance = &Factory::getDB($somekickoff);

Dann behandeln Sie einfach alle Methoden als nicht statisch (weil sie es sind)

echo $static_instance->getvar();

Objekt kann nicht statisch definiert werden, aber das funktioniert

final Class B{
  static $var;
  static function init(){
    self::$var = new A();
}
B::init();