¿Es posible crear clases estáticas en PHP (como en C #)?

Quiero crear una clase estática en PHP y hacer que se comporte como lo hace en C #, así que

1. Se llama automáticamente al constructor en la primera llamada a la clase
2. No se requiere instanciación

Algo de este tipo ...

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

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

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

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

Puede tener clases estáticas en PHP, pero no llaman al constructor automáticamente (si intenta llamar self::__construct(), obtendrá un error).

Por lo tanto, tendría que crear una initialize()función y llamarla en 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!


?>

Además de la respuesta de Greg, recomendaría establecer el constructor privado para que sea imposible crear una instancia de la clase.

Entonces, en mi humilde opinión, este es un ejemplo más completo basado en el 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!


?>

puedes tener esas clases "estáticas". pero supongo que falta algo realmente importante: en php no tienes un ciclo de aplicación, por lo que no obtendrás una estática real (o singleton) en toda tu aplicación ...

ver Singleton en PHP

final Class B{

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

la estructura de b se llama un controlador de singeton, también puede hacerlo en un

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

este es el uso singleton $a = a::getA(...);

Generalmente prefiero escribir clases regulares no estáticas y usar una clase de fábrica para crear instancias individuales (sudo estáticas) del objeto.

De esta forma, el constructor y el destructor funcionan de manera normal, y puedo crear instancias no estáticas adicionales si lo deseo (por ejemplo, una segunda conexión de base de datos)

Lo uso todo el tiempo y es especialmente útil para crear controladores de sesión de almacenamiento de base de datos personalizados, ya que cuando la página termina, el destructor empujará la sesión a la base de datos.

Otra ventaja es que puede ignorar el orden en que llama a las cosas, ya que todo se configurará a pedido.

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 clase DB ...

class clsDB {

    $regular_public_variables = "whatever";

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

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

En cualquier lugar que desee usar, simplemente llame ...

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

Luego, trate todos los métodos como no estáticos (porque lo son)

echo $static_instance->getvar();

el objeto no se puede definir estáticamente pero esto funciona

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