What is a static class php?

Tip

This page describes the use of the static keyword to define static methods and properties. static can also be used to define static variables and for late static bindings. Please refer to those pages for information on those meanings of static.

Declaring class properties or methods as static makes them accessible without needing an instantiation of the class. These can also be accessed statically within an instantiated class object.

Static methods

Because static methods are callable without an instance of the object created, the pseudo-variable $this is not available inside methods declared as static.

Warning

Calling non-static methods statically throws an Error.

Prior to PHP 8.0.0, calling non-static methods statically were deprecated, and generated an E_DEPRECATED warning.

Example #1 Static method example

class Foo {
    public static function aStaticMethod() {
        // ...
    }
}Foo::aStaticMethod();
$classname = 'Foo';
$classname::aStaticMethod();
?>

Static properties

Static properties are accessed using the Scope Resolution Operator (::) and cannot be accessed through the object operator (->).

It's possible to reference the class using a variable. The variable's value cannot be a keyword (e.g. self, parent and static).

Example #2 Static property example

class Foo
{
    public static $my_static = 'foo';

    public function

Output of the above example in PHP 8 is similar to:

foo
foo

Notice: Accessing static property Foo::$my_static as non static in /in/V0Rvv on line 23

Warning: Undefined property: Foo::$my_static in /in/V0Rvv on line 23

foo
foo
foo
foo

inkredibl ¶

14 years ago

Note that you should read "Variables/Variable scope" if you are looking for static keyword use for declaring static variables inside functions (or methods). I myself had this gap in my PHP knowledge until recently and had to google to find this out. I think this page should have a "See also" link to static function variables.
http://www.php.net/manual/en/language.variables.scope.php

payal001 at gmail dot com ¶

11 years ago

Here statically accessed property prefer property of the class for which it is called. Where as self keyword enforces use of current class only. Refer the below example:

class a{

static protected

artekpuck at gmail dot com ¶

4 years ago

It is worth mentioning that there is only one value for each static variable that is the same for all instances

admin at shopinson dot com ¶

2 years ago

I used instantiation to access the access the a static property directly.

A Simple ticky art, you may apply (using object to access static property in a class) with the scope resolution operator
class Shopinson {
    const MY_CONSTANT = 'the value of MY_CONSTANT ';
}

class

Anonymous ¶

17 years ago

You misunderstand the meaning of inheritance : there is no duplication of members when you inherit from a base class. Members are shared through inheritance, and can be accessed by derived classes according to visibility (public, protected, private).

The difference between static and non static members is only that a non static member is tied to an instance of a class although a static member is tied to the class, and not to a particular instance.
That is, a static member is shared by all instances of a class although a non static member exists for each instance of  class.

Thus, in your example, the static property has the correct value, according to principles of object oriented conception.
class Base
{
  public $a;
  public static $b;
}

class Derived extends Base
{
  public function __construct()
  {
    $this->a = 0;
    parent::$b = 0;
  }
  public function f()
  {
    $this->a++;
    parent::$b++;
  }
}

$i1 = new Derived;
$i2 = new Derived;

$i1->f();
echo $i1->a, ' ', Derived::$b, "\n";
$i2->f();
echo $i2->a, ' ', Derived::$b, "\n";

outputs
1 1
1 2

Anonymous ¶

8 years ago

It should be noted that in 'Example #2', you can also call a variably defined static method as follows:

class Foo {
    public static function aStaticMethod() {
        // ...
    }
}$classname = 'Foo';
$methodname = 'aStaticMethod';
$classname::{$methodname}(); // As of PHP 5.3.0 I believe
?>

ASchmidt at Anamera dot net ¶

4 years ago

It is important to understand the behavior of static properties in the context of class inheritance:

- Static properties defined in both parent and child classes will hold DISTINCT values for each class. Proper use of self:: vs. static:: are crucial inside of child methods to reference the intended static property.

- Static properties defined ONLY in the parent class will share a COMMON value.

declare(strict_types=1);

class

rahul dot anand77 at gmail dot com ¶

6 years ago

To check if a method declared in a class is static or not, you can us following code. PHP5 has a Reflection Class, which is very helpful.

try {
    $method = new ReflectionMethod( 'className::methodName );
    if ( $method->isStatic() )
    {
        // Method is static.
    }
}
catch ( ReflectionException $e )
{
    //    method does not exist
    echo $e->getMessage();
}

*You can read more about Reflection class on http://php.net/manual/en/class.reflectionclass.php

davidn at xnet dot co dot nz ¶

13 years ago

Static variables are shared between sub classes

class MyParent {

        protected static

sideshowAnthony at googlemail dot com ¶

6 years ago

The static keyword can still be used (in a non-oop way) inside a function. So if you need a value stored with your class, but it is very function specific, you can use this:

class aclass {
    public static function b(){
        static $d=12; // Set to 12 on first function call only
        $d+=12;
        return "$d\n";
    }
}

echo aclass::b(); //24
echo aclass::b(); //36
echo aclass::b(); //48
echo aclass::$d; //fatal error

tolean_dj at yahoo dot com ¶

11 years ago

Starting with php 5.3 you can get use of new features of static keyword. Here's an example of abstract singleton class:

abstract class Singleton {

    protected static

webmaster at removethis dot weird-webdesign dot de ¶

12 years ago

On PHP 5.2.x or previous you might run into problems initializing static variables in subclasses due to the lack of late static binding:

class A {
    protected static $a;

        public static function

manishpatel2280 at gmail dot com ¶

8 years ago

In real world, we can say will use static method when we dont want to create object instance.

e.g ...

validateEmail($email) {
if(T) return true;
return false;
}

//This makes not much sense
$obj = new Validate();
$result = $obj->validateEmail($email);

//This makes more sense
$result = Validate::validateEmail($email);

ssj dot narutovash at gmail dot com ¶

14 years ago

It's come to my attention that you cannot use a static member in an HEREDOC string.  The following code

class A
{
  public static $BLAH = "user";

  function __construct()
  {
    echo <<

Hello {self::$BLAH}

$blah = new A();

produces this in the source code:

Hello {self::}

Solution:

before using a static member, store it in a local variable, like so:

class B
{
  public static $BLAH = "user";

  function __construct()
  {
    $blah = self::$BLAH;
    echo <<

Hello {$blah}

and the output's source code will be:

Hello user

b1tchcakes ¶

6 years ago

trait t {
  protected $p;
  public function testMe() {echo 'static:'.static::class. ' // self:'.self::class ."\n";}
}

class

zerocool at gameinsde dot ru ¶

13 years ago

Hi, here's my simple Singleton example, i think it can be useful for someone. You can use this pattern to connect to the database for example.

class MySingleton
  {
    private static $instance = null;

    private function

gratcypalma at gmail dot om ¶

11 years ago

class foo {
    private static $getInitial;

    public static function

michalf at ncac dot torun dot pl ¶

17 years ago

Inheritance with the static elements is a nightmare in php. Consider the following code:

class BaseClass{
    public static $property;
}

class

Jay Cain ¶

12 years ago

Regarding the initialization of complex static variables in a class, you can emulate a static constructor by creating a static function named something like init() and calling it immediately after the class definition.

class Example {
    private static $a = "Hello";
    private static $b;

    public static function

Mirco ¶

12 years ago

The simplest static constructor.

Because php does not have a static constructor and you may want to initialize static class vars, there is one easy way, just call your own function directly after the class definition.

for example.

function Demonstration()
{
    return 'This is the result of demonstration()';
}

class

valentin at balt dot name ¶

12 years ago

How to implement a one storage place based on static properties.

class a {

        public function

jkenigso at utk dot edu ¶

8 years ago

It bears mention that static variables (in the following sense) persist:

class StaticVars
{
  public static $a=1;
}
$b=new StaticVars;
$c=new StaticVars;

echo

michael at digitalgnosis dot removethis dot com ¶

17 years ago

If you are trying to write classes that do this:

class Base
{
    static function Foo ()
    {
        self::Bar();
    }
}

class

vvikramraj at yahoo dot com ¶

14 years ago

when attempting to implement a singleton class, one might also want to either
a) disable __clone by making it private
b) bash the user who attempts to clone by defining __clone to throw an exception

Mathijs Vos ¶

14 years ago

class foo
{
    public static $myStaticClass;

        public function

fakhar_anwar123 at hotmail dot com ¶

2 years ago

Asnwer selcted as correct solves problem. There is a valid use case (Design Pattern) where class with static member function needs to call non-static member function and before that this static members should also instantiate singleton using constructor a constructor.

**Case:**
For example, I am implementing Swoole HTTP Request event providing it a call-back as a Class with static member. Static Member does two things; it creates Singleton Object of the class by doing initialization in class constructor, and second this static members does is to call a non-static method 'run()' to handle Request (by bridging with Phalcon). Hence, static class without constructor and non-static call will not work for me.