PHP – Static Methods

In PHP, static methods belong to the class rather than an instance of the class. This means you can call a static method directly using the class name, without creating an object of that class.

Key Features of Static Methods
Direct Access:

Static methods can be accessed without creating an instance of the class.
Declared with static:

The static keyword is used to declare a static method.
Cannot Access $this:

Static methods cannot use the $this keyword because they are not tied to any specific instance.
Used for Utility Functions:

Static methods are often used for tasks like utility functions that do not depend on instance data.

<?php
class ClassName {
  public static function staticMethod() {
    echo "Static Method Called!";
  }
}

// Calling the static method
ClassName::staticMethod();
?>

Example 1: Basic Static Method

<?php
class Greeting {
  public static function welcome() {
    echo "Hello, World!";
  }
}

// Calling the static method without creating an instance
Greeting::welcome(); // Outputs: Hello, World!
?>

Example 2: Static and Non-Static Methods
A class can contain both static and non-static methods. You can call a static method from a non-static method using the self keyword.

<?php
class Greeting {
  public static function welcome() {
    echo "Hello, World!";
  }

  public function __construct() {
    // Call static method from a non-static context
    self::welcome();
  }
}

new Greeting(); // Outputs: Hello, World!
?>

Example 3: Static Methods in Different Classes
Static methods can be called from other classes using the class name.

?php
class A {
  public static function welcome() {
    echo "Hello from Class A!";
  }
}

class B {
  public function message() {
    // Call the static method from Class A
    A::welcome();
  }
}

// Create an instance of Class B and call the method
$obj = new B();
$obj->message(); // Outputs: Hello from Class A!
?>

Example 4: Static Methods in Inheritance
You can call a static method from a parent class in a child class using the parent keyword

<?php
class Domain {
  protected static function getWebsiteName() {
    return "Example.com";
  }
}

class SubDomain extends Domain {
  public $websiteName;

  public function __construct() {
    // Access the parent class static method
    $this->websiteName = parent::getWebsiteName();
  }
}

// Instantiate SubDomain and access the website name
$subDomain = new SubDomain();
echo $subDomain->websiteName; // Outputs: Example.com
?>

Key Points to Remember
Static Methods Are Shared:

Static methods belong to the class and are shared among all instances.
No $this Access:

Since static methods are not tied to any instance, the $this keyword cannot be used.
Access Levels:

Static methods can have public, protected, or private visibility.
Inheritance:

Static methods can be inherited by child classes, and parent:: can be used to access them.
When to Use Static Methods
Utility Methods:

Functions that perform a specific task and do not require instance data, such as mathematical calculations or string operations.
Singleton Pattern:

Static methods are often used in design patterns like the Singleton, where a single shared instance of a class is maintained.
Shared Data:

When working with constants or shared data that do not depend on object-specific information.
Conclusion
Static methods in PHP provide a way to define and call class-level methods that do not rely on instance-specific data. They are useful for creating utility functions, implementing design patterns, and promoting code reusability. Understanding when and how to use static methods is essential for building efficient and organized PHP applications.