Static Properties & Methods

Introduction

Every property and method you have written so far has belonged to a specific object — each instance of a class gets its own independent copy of its properties. But sometimes you need data or behavior that belongs to the class as a whole, shared by every instance, or usable without creating any instance at all. That is exactly what the `static` keyword provides.

A common example is tracking how many objects of a class have ever been created — that count does not belong to any one object, it belongs to the class itself.

What Does static Mean?

Marking a property or method `static` means it belongs to the class itself, not to any individual object created from that class. There is only ever one copy of a static property, shared across every instance, and static methods can be called without creating an object at all.

Static Properties

A static property is declared with the `static` keyword and accessed using the scope resolution operator `::` on the class name, rather than `->` on an object.

<?php
class Configuration
{
    public static string $appName = "PrograMinds";
}

echo Configuration::$appName;

PrograMinds

Notice the syntax: `Configuration::$appName`, with the `$` still in front of the property name, unlike static method calls.

Static Methods

A static method is also declared with `static` and is called the same way, using `ClassName::method()`. Static methods cannot use `$this`, because they are not tied to any particular instance.

<?php
class MathHelper
{
    public static function square(int $number): int
    {
        return $number * $number;
    }
}

echo MathHelper::square(6);

36

You never wrote `new MathHelper()` here — the method is called directly on the class, since it does not depend on any object state.

The self:: Keyword

Inside a class's own methods, you can refer to its static members using `self::` instead of repeating the class name. This is especially useful because it keeps working correctly even if the class is later renamed.

<?php
class Circle
{
    public static float $pi = 3.14159;

    public static function area(float $radius): float
    {
        return self::$pi * $radius * $radius;
    }
}

echo Circle::area(5);

78.53975

Worked Example: Instance Counter

A classic use case for static properties is counting how many objects of a class have been created. Every instance shares and updates the same static counter.

<?php
class User
{
    private static int $totalUsers = 0;

    public function __construct(private string $name)
    {
        self::$totalUsers++;
    }

    public static function getTotalUsers(): int
    {
        return self::$totalUsers;
    }
}

new User("Amol");
new User("Priya");
new User("Rahul");

echo "Total users created: " . User::getTotalUsers();

Total users created: 3

Each `new User(...)` call increments the same shared `$totalUsers` property via the constructor. Because the counter is static, all three instances contributed to one running total, accessible even without holding a reference to any specific `User` object.

Static vs Instance Members

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Static properties and methods let you attach data and behavior to a class itself, rather than to any one instance. This is useful whenever information — like a running count, shared configuration, or a utility function — genuinely belongs at the class level.

In this lesson, you learned how to declare and access static properties and methods, how `self::` refers to the current class, and how a static counter can track instances across an entire application. Next, you will learn about PHP filters, used to validate and sanitize data such as user input.