Est-il possible de créer des classes statiques en PHP (comme en C #)?

Je veux créer une classe statique en PHP et la faire se comporter comme elle le fait en C #, donc

1. Le constructeur est automatiquement appelé au premier appel de la classe
2. Aucune instanciation requise

Quelque chose de ce genre ...

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

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

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

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

Vous pouvez avoir des classes statiques en PHP mais elles n'appellent pas automatiquement le constructeur (si vous essayez d'appeler, self::__construct()vous obtiendrez une erreur).

Par conséquent, vous devrez créer une initialize()fonction et l'appeler dans chaque méthode:

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


?>

En plus de la réponse de Greg, je recommanderais de définir le constructeur private afin qu'il soit impossible d'instancier la classe.

Donc, à mon humble avis, c'est un exemple plus complet basé sur celui de 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!


?>

vous pouvez avoir ces classes "statiques". mais je suppose qu'il manque quelque chose de vraiment important: en php, vous n'avez pas de cycle d'application, vous n'obtiendrez donc pas de véritable statique (ou singleton) dans toute votre application ...

voir Singleton en PHP

final Class B{

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

la structure de b est appelée un gestionnaire singeton, vous pouvez également le faire dans un

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

c'est l'usage singleton $a = a::getA(...);

Je préfère généralement écrire des classes non statiques régulières et utiliser une classe factory pour instancier des instances uniques (sudo static) de l'objet.

De cette façon, le constructeur et le destructeur fonctionnent comme d'habitude, et je peux créer des instances non statiques supplémentaires si je le souhaite (par exemple une deuxième connexion DB)

Je l'utilise tout le temps et est particulièrement utile pour créer des gestionnaires de session de magasin de base de données personnalisés, car lorsque la page se termine, le destructeur pousse la session vers la base de données.

Un autre avantage est que vous pouvez ignorer l'ordre dans lequel vous appelez les choses, car tout sera configuré à la demande.

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

Partout où vous voulez l'utiliser, appelez simplement ...

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

Ensuite, traitez simplement toutes les méthodes comme non statiques (car elles le sont)

echo $static_instance->getvar();

l'objet ne peut pas être défini de manière statique mais cela fonctionne

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