I want to create a static class in PHP and have it behave like it does in C#, so
Something of this sort...
static class Hello {
private static $greeting = 'Hello';
private __construct() {
$greeting .= ' There!';
}
public static greet(){
echo $greeting;
}
}
Hello::greet(); // Hello There!
You can have static classes in PHP but they don't call the constructor automatically (if you try and call self::__construct() you'll get an error).
Therefore you'd have to create an initialize() function and call it in each method:
<?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!
?>
In addition to Greg's answer, I would recommend to set the constructor private so that it is impossible to instantiate the class.
So in my humble opinion this is a more complete example based on Greg's one:
<?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!
?>
you can have those "static"-like classes. but i suppose, that something really important is missing: in php you don't have an app-cycle, so you won't get a real static (or singleton) in your whole application...
see Singleton in PHP
final Class B{
static $staticVar;
static function getA(){
self::$staticVar = New A;
}
}
the stucture of b is calld a singeton handler you can also do it in a
Class a{
static $instance;
static function getA(...){
if(!isset(self::$staticVar)){
self::$staticVar = New A(...);
}
return self::$staticVar;
}
}
this is the singleton use
$a = a::getA(...);
I generally prefer to write regular non static classes and use a factory class to instantiate single ( sudo static ) instances of the object.
This way constructor and destructor work as per normal, and I can create additional non static instances if I wish ( for example a second DB connection )
I use this all the time and is especially useful for creating custom DB store session handlers, as when the page terminates the destructor will push the session to the database.
Another advantage is you can ignore the order you call things as everything will be setup on demand.
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;
}
}
The DB class...
class clsDB {
$regular_public_variables = "whatever";
function __construct($construct_params) {...}
function __destruct() {...}
function getvar() { return $this->regular_public_variables; }
}
Anywhere you want to use it just call...
$static_instance = &Factory::getDB($somekickoff);
Then just treat all methods as non static ( because they are )
echo $static_instance->getvar();
object cannot be defined staticly but this works
final Class B{
static $var;
static function init(){
self::$var = new A();
}
B::init();