Static Properties and Methods: Class-Level Variables and Functions

Static members belong to the class itself, not to any specific instance. Think of them as shared resources among all objects of that class.

Static Properties: Shared Data

<?php
class User {
    // Static property - shared among all User objects
    private static $userCount = 0;
    
    // Regular instance properties
    public $username;
    public $email;
    private $password;
    
    public function __construct($username, $email, $password) {
        $this->username = $username;
        $this->email = $email;
        $this->password = password_hash($password, PASSWORD_DEFAULT);
        
        // Increment the static user count
        self::$userCount++;
    }
    
    // Static method to access static property
    public static function getUserCount() {
        return self::$userCount;
    }
    
    // Regular instance method
    public function displayInfo() {
        echo "Username: {$this->username}, Email: {$this->email}
";
        echo "You are user #" . self::$userCount . "
";
    }
}

// Static properties and methods can be accessed without creating an object
echo "Initial user count: " . User::getUserCount() . "
"; // Output: 0

// Create some users
$user1 = new User("john_doe", "john@example.com", "password123");
$user2 = new User("jane_smith", "jane@example.com", "secure456");

// Access static method again
echo "Current user count: " . User::getUserCount() . "
"; // Output: 2

// We can also access static properties/methods through an instance 
// (though this is not recommended for clarity)
echo "User count via instance: " . $user1::getUserCount() . "
";

// Display individual user info
$user1->displayInfo();
$user2->displayInfo();
?>

Static vs. Non-Static: When to Use Each

<?php
class DatabaseConnection {
    // Static property holding the single connection
    private static $connection = null;
    
    // Private constructor prevents direct instantiation
    private function __construct() {
        // This won't be called directly
    }
    
    // Static method to get the connection (Singleton pattern)
    public static function getConnection() {
        if (self::$connection === null) {
            echo "Creating new database connection...
";
            // In real code, this would connect to a database
            self::$connection = "Database Connection Object";
        } else {
            echo "Reusing existing database connection...
";
        }
        
        return self::$connection;
    }
}

// Using the static method - first time creates connection
$db1 = DatabaseConnection::getConnection();
echo "DB1: " . $db1 . "
";

// Second time reuses the same connection
$db2 = DatabaseConnection::getConnection();
echo "DB2: " . $db2 . "
";

// This won't work - constructor is private
// $dbDirect = new DatabaseConnection(); // Error!
?>

The code above demonstrates the Singleton pattern, commonly used in WordPress for things like the global $wpdb database connection.

Static Methods in WordPress

WordPress uses static methods frequently. For example, the helper class WP_Query has static methods like get_posts().

<?php
// Example similar to WordPress helper class
class WP_Theme_Helper {
    // Static utility methods
    public static function get_theme_directory() {
        return '/wp-content/themes/current-theme';
    }
    
    public static function asset_url($file) {
        return self::get_theme_directory() . '/assets/' . $file;
    }
    
    public static function featured_image_markup($post_id, $size = 'thumbnail') {
        $image_url = "/path/to/image_{$size}.jpg"; // Simplified example
        return "";
    }
}

// Using static methods without instantiation
echo WP_Theme_Helper::get_theme_directory() . "
";
echo "
";
echo WP_Theme_Helper::featured_image_markup(123, 'medium');
?>