É possível criar classes estáticas em PHP (como em C #)?

Eu quero criar uma classe estática em PHP e fazê-la se comportar como em C #, então

1. O construtor é chamado automaticamente na primeira chamada da classe
2. Não é necessária instanciação

Algo desse tipo ...

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

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

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

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

Você pode ter classes estáticas no PHP, mas elas não chamam o construtor automaticamente (se você tentar chamar, self::__construct()você receberá um erro).

Portanto, você teria que criar uma initialize()função e chamá-la em cada método:

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


?>

Além da resposta de Greg, eu recomendaria definir o construtor como privado para que seja impossível instanciar a classe.

Então, na minha humilde opinião, este é um exemplo mais completo, baseado no 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!


?>

você pode ter essas classes "estáticas". mas suponho que algo realmente importante esteja faltando: no php você não tem um ciclo de aplicativos, para que não obtenha uma estática real (ou singleton) em todo o aplicativo ...

veja Singleton em PHP

final Class B{

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

a estrutura de b é chamada de manipulador singeton, você também pode fazê-lo em um

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

este é o uso singleton $a = a::getA(...);

Geralmente, prefiro escrever classes não estáticas regulares e usar uma classe de fábrica para instanciar instâncias únicas (sudo static) do objeto.

Dessa forma, o construtor e o destruidor funcionam normalmente, e eu posso criar instâncias não estáticas adicionais, se desejar (por exemplo, uma segunda conexão com o banco de dados)

Eu uso isso o tempo todo e é especialmente útil para criar manipuladores de sessão personalizados do repositório de banco de dados, pois quando a página termina, o destruidor envia a sessão ao banco de dados.

Outra vantagem é que você pode ignorar a ordem em que chama as coisas, pois tudo será configurado sob demanda.

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

A classe DB ...

class clsDB {

    $regular_public_variables = "whatever";

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

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

Em qualquer lugar que você quiser usá-lo, basta ligar para ...

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

Em seguida, trate todos os métodos como não estáticos (porque são)

echo $static_instance->getvar();

O objeto não pode ser definido estático, mas isso funciona

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