web-dev-qa-db-fra.com

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

Je veux créer une classe statique dans PHP et qu'elle se comporte comme elle le fait en C #, donc

  1. Le constructeur est automatiquement appelé lors du premier appel à 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!
phpdesign-patternsoopstatic
134
aleemb

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

Par conséquent, vous devez créer une fonction initialize() 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!


?>
195
Greg

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

Donc, à mon humble avis, ceci 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!


?>
50
Phil

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

voir Singleton en PHP

24
Andreas Niedermair
final Class B{

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

la structure de b est appelée un gestionnaire de singleton, 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'utilisation singleton $a = a::getA(...);

4
borrel

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

De cette façon, le constructeur et le destructeur fonctionnent normalement, et je peux créer des instances supplémentaires non statiques si je le souhaite (par exemple, une deuxième connexion à une base de données).

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 envoie la session à 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, il vous suffit d'appeler ...

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

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

echo $static_instance->getvar();
3
dave.zap

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();
2
borrel