In PHP, static properties and methods are class members that are not tied to any specific instance of a class but belong to the class itself. They are useful when you need to maintain state or functionality that is shared across all instances of a class, or when you simply want to access a method or property without creating an object of that class.

Static Properties and Methods

1. Static Properties: These are variables associated with the class itself rather than any object instance. They are shared among all instances of the class.

2. Static Methods: These are functions that belong to the class and can be called without creating an object. They also cannot access non-static properties directly since they do not operate on a particular instance of the class.

Declaring and Accessing Static Properties and Methods

Static members are declared using the static keyword. They are accessed using the :: scope resolution operator, often called the Paamayim Nekudotayim.

Example

class MathUtility {
    // Static property
    public static $pi = 3.14159;

    // Static method
    public static function square($number) {
        return $number * $number;
    }

    // Static method accessing static property
    public static function areaOfCircle($radius) {
        return self::$pi * self::square($radius);
    }
}

// Accessing static property
echo MathUtility::$pi; // Outputs: 3.14159

// Accessing static method
echo MathUtility::square(4); // Outputs: 16

// Accessing another static method that uses both a static method and a static property
echo MathUtility::areaOfCircle(3); // Outputs: 28.27431

Explanation

1. Static Property ($pi):

   • Defined using public static $pi.
   • Accessed using MathUtility::$pi.

2. Static Method (square()):

   • Defined using public static function square($number).
   • Accessed using MathUtility::square(4).

3. Static Method Using self:

   • To access static properties or methods within the class, the self keyword is used (self::$pi and self::square()).
   • This is because self refers to the current class, whereas $this refers to an instance of the class, and static methods do not have an instance context.

Characteristics of Static Members

• Shared State: Static properties hold values shared across all instances of a class. If you change the value of a static property, it is changed for all instances.

  class Counter {
      public static $count = 0;
  
      public static function increment() {
          self::$count++;
      }
  }
  
  Counter::increment();
  Counter::increment();
  echo Counter::$count; // Outputs: 2
  

• No Instance Required: You can use static methods or properties without creating an instance of the class. This makes static members ideal for utility classes (e.g., mathematical operations, string manipulations) or for properties that track data at the class level.

• Cannot Access Non-Static Members: Static methods cannot directly access non-static properties or methods, as they do not operate within the context of an object instance.

  class Example {
      public $instanceProperty = 'I am an instance property';
      public static $staticProperty = 'I am a static property';
  
      public static function show() {
          // This will cause an error because $this is not available
          // echo $this->instanceProperty; 
  
          // Correct way to access static properties
          echo self::$staticProperty;
      }
  }
  

Practical Use Cases

1. Utility or Helper Classes: Static methods are often used for utility classes, such as mathematical functions, data formatting, etc., where creating an object is unnecessary.

   class StringUtils {
       public static function toUpperCase($string) {
           return strtoupper($string);
       }
   }
   
   echo StringUtils::toUpperCase("hello"); // Outputs: HELLO
   

2. Keeping Track of State: Static properties can be used to maintain state across all instances of a class, such as maintaining a counter for how many instances of a class have been created.

   class InstanceTracker {
       public static $instanceCount = 0;
   
       public function __construct() {
           self::$instanceCount++;
       }
   }
   
   $a = new InstanceTracker();
   $b = new InstanceTracker();
   
   echo InstanceTracker::$instanceCount; // Outputs: 2
   

Summary

• Static Properties and Methods:
  • Static Properties are variables belonging to the class itself.
  • Static Methods are functions that can be called without creating an object.
• Usage:
  • Accessed via the :: operator.
  • Useful for utility operations or maintaining shared state.
• Limitations:
  • Static methods cannot access non-static properties directly, as they do not have an object context.

Static members are a powerful feature in PHP's object-oriented programming, providing shared state and utility functionalities without requiring an instance of the class.