We discussed public and private Access Modifiers earlier. Sometimes, we require access to a Class’s members without creating an object. In this situation, we use Static Keyword in PHP. Defining a class property static makes it accessible without instantiating an object of the class. In this article, we will discuss the use of Static Keyword in PHP.
Please go through the introduction of Object Oriented Programming in PHP first.
Difference Between Non-Static and Static Members
The following table explains the difference between Static and Non-Static Members.
Criteria | Non-Static Member | Static Member |
Class/Object Level | They are Object Level Members. | They are Class Level Members. |
Copies | Every Object has a different copy. | The whole class has a single copy. |
Calling | An object instance is required to call the member. | Members are called directly using the Class Name. From within the class, self keyword is used. |
Memory Allocation | Every Object has a different Memory Allocation. | All the Objects have a single Memory Allocation for Static Members. |
Basic Usage of Static Keyword
For instance, let’s go through the basic usage of Static Keyword.
<?php class Logger { public static $logPath = '/tmp/log/'; } echo Logger::$logPath; ///tmp/log/ ?>
We have a Logger class in the above example. Also, there is a static member variable logPath. In order to access the static variable, we don’t need to initialize an object of the class. We can do it directly using the Class Name as shown.
Static Methods
Similarly, we can define Static Methods also. Static Methods are also called using the class reference. Static Methods should be used in a case when you don’t need an object reference inside the method.
Warning: In PHP 7, calling non-static methods statically is deprecated, and will generate an E_DEPRECATED warning. Support for calling non-static methods statically may be removed in the future.
<?php class Logger { private static $logPath = '/tmp/log/'; public static function log() { echo 'Log Method Called'; } } Logger::log() //Log Method Called ?>
We have added a static log method in the Logger Class. We can call that method with the class name without instantiating an object.
When to Define Static Methods?
You should create a static method when it makes sense to call it without needing an object. If a logic can be shared by different methods then it can be copied in a static method. PHP static methods are often used in utility classes of PHP frameworks. A utility class is a class that contains only static methods.
Self Keyword: Accessing Static Members in Methods
We can also have Private Static Members. Also, we might need to access a static member within the class. You can use the ‘self’ keyword to access static members within the class.
<?php class Logger { private static $logPath = '/tmp/log/'; public static function log() { echo self::$logPath; } } Logger::log() ///tmp/log/ ?>
The static log method is called with the class name. Inside the log method, the static member logPath can be accessed by using the self keyword.
self vs $this Keyword
This brings us to a very important question. What is the difference between $this and self? It looks a bit confusing to many developers. Hence, they decide not to use static members at all!
$this | self |
Reference to the Object | Reference to the Class |
It is followed by -> operator | It is followed by :: operator |
Cannot be used in static methods. | Can be used in static and non-static methods. |
Using $this in Static Methods
We don’t need to create an object to call a Static Method. As a result, we don’t have any object reference inside the called method. Hence, $this is not available inside a Static Method. For example, go through the code snippet:
<?php class Logger { private static $logPath = '/tmp/log/'; private $logLevel = 1; public static function log() { echo $this->logLevel; //Fatal error: Uncaught Error: Using $this when not in object context } } Logger::log() ?>
Accessing a non-static property logLevel inside a static method results in a Fatal Error. However, you may access static members in a non-static method by using the self keyword.
Memory Allocation
Static Members have the same memory allocated for the whole class. Therefore, all the different objects refer to the same memory when accessing a static member. For instance, consider the following code snippet:
<?php class Counter { private static $count = 10; private $nonStaticVariable = 5; public function doCount() { self::$count++; } public function incrementNonStaticVariable() { $this->nonStaticVariable++; } public function getNonStaticVariable() { return $this->nonStaticVariable; } public function getCount() { return self::$count; } } $counter1 = new Counter(); $counter2 = new Counter(); $counter1->incrementNonStaticVariable(); print_r($counter2->getNonStaticVariable()); //Prints 5 as the variable is non static and all obejcts have different memory allocations $counter1->doCount(); print_r($counter2->getCount()); // Prints 11 as the $count is static and only one memory is allocated for the whole class ?>
- We define a Counter class with one static and one non-static member variable.
- Instantiate 2 objects of the Counter Class ($counter1 and $counter2).
- Increment the non static variable value for $counter1. We observe that the non static value of $counter2 is not incremented and is the same.
- Now, increment the static member value ($count) for $counter1. It can be observed, the static member for $counter2 is also incremented as they both share the same memory.
Conclusion
In conclusion, we discussed the use of Static Keyword in this article. It is very important to understand it’s working for future articles. Also, you may read more about static variable on PHP Official Documentation.

Vishesh is currently working as a Lead Software Engineer at Naukri.com. He passed out of Delhi College of Engineering in 2016 and likes to play Foosball. He loves traveling and is an exercise freak. His expertise includes Java, PHP, Python, Databases, Design and Architecture.