Czy można tworzyć klasy statyczne w PHP (jak w C #)?

Chcę utworzyć klasę statyczną w PHP i sprawić, by zachowywała się tak, jak w C #, więc

1. Konstruktor jest wywoływany automatycznie przy pierwszym wywołaniu klasy
2. Nie jest wymagana żadna instancja

Coś w tym rodzaju ...

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

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

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

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

Możesz mieć statyczne klasy w PHP, ale nie wywołują one konstruktora automatycznie (jeśli spróbujesz wywołać self::__construct(), pojawi się błąd).

Dlatego musiałbyś stworzyć initialize()funkcję i wywołać ją w każdej metodzie:

<?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!


?>

Oprócz odpowiedzi Grega zalecałbym ustawienie konstruktora jako prywatnego, aby nie było możliwe utworzenie instancji klasy.

Moim skromnym zdaniem jest to bardziej kompletny przykład oparty na przykładzie Grega:

<?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!


?>

możesz mieć te „statyczne” klasy. ale przypuszczam, że brakuje czegoś naprawdę ważnego: w php nie masz cyklu aplikacji, więc nie dostaniesz prawdziwego statycznego (lub pojedynczego) w całej aplikacji ...

zobacz Singleton w PHP

final Class B{

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

struktura b jest nazywana pojedynczym handlerem, możesz to również zrobić w a

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

to jest użycie singletona $a = a::getA(...);

Generalnie wolę pisać zwykłe niestatyczne klasy i używać klasy fabrycznej do tworzenia instancji pojedynczych (sudo static) instancji obiektu.

W ten sposób konstruktor i destruktor działają normalnie i mogę tworzyć dodatkowe niestatyczne instancje, jeśli chcę (na przykład drugie połączenie DB)

Używam tego przez cały czas i jest to szczególnie przydatne do tworzenia niestandardowych programów obsługi sesji w bazie danych, ponieważ gdy strona kończy działanie, destruktor wypycha sesję do bazy danych.

Kolejną zaletą jest to, że możesz zignorować kolejność, którą nazywasz, ponieważ wszystko zostanie skonfigurowane na żądanie.

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;
    }
}

Klasa DB ...

class clsDB {

    $regular_public_variables = "whatever";

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

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

Gdziekolwiek chcesz go używać, po prostu zadzwoń ...

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

Następnie potraktuj wszystkie metody jako niestatyczne (ponieważ są)

echo $static_instance->getvar();

obiektu nie można zdefiniować statycznie, ale to działa

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