È possibile creare classi statiche in PHP (come in C #)?

Voglio creare una classe statica in PHP e farla comportare come in C #, quindi

1. Il costruttore viene chiamato automaticamente alla prima chiamata alla classe
2. Nessuna istanza richiesta

Qualcosa del genere ...

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

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

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

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

Puoi avere classi statiche in PHP ma non chiamano automaticamente il costruttore (se provi a chiamare self::__construct()otterrai un errore).

Pertanto dovresti creare una initialize()funzione e chiamarla in ciascun metodo:

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


?>

Oltre alla risposta di Greg, consiglierei di impostare il costruttore come privato in modo che sia impossibile creare un'istanza della classe.

Quindi, a mio modesto parere, questo è un esempio più completo basato su quello di Greg:

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


?>

puoi avere quelle classi "statiche". ma suppongo che manchi qualcosa di veramente importante: in php non hai un ciclo di app, quindi non otterrai un vero statico (o singleton) in tutta la tua applicazione ...

vedi Singleton in PHP

final Class B{

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

la struttura di b è chiamata un gestore singeton puoi anche farlo in a

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

questo è l'uso singleton $a = a::getA(...);

In genere preferisco scrivere normali classi non statiche e utilizzare una classe factory per istanziare singole istanze (sudo statiche) dell'oggetto.

In questo modo il costruttore e il distruttore funzionano come al solito e, se lo desidero, posso creare ulteriori istanze non statiche (ad esempio una seconda connessione DB)

Lo uso sempre ed è particolarmente utile per la creazione di gestori di sessioni di archivio DB personalizzati, poiché quando la pagina termina il distruttore invierà la sessione al database.

Un altro vantaggio è che puoi ignorare l'ordine che chiami le cose poiché tutto sarà impostato su richiesta.

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

La classe DB ...

class clsDB {

    $regular_public_variables = "whatever";

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

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

Ovunque tu voglia usarlo basta chiamare ...

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

Quindi tratta tutti i metodi come non statici (perché lo sono)

echo $static_instance->getvar();

l'oggetto non può essere definito staticamente ma funziona

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