PHP static: Static Methods, Properties and self vs static

A static method or property belongs to the class itself rather than to any object. You call a static method with ClassName::method() and read a static property with ClassName::$property, without creating an object first. Inside the class, self:: refers to the same members.

<?php
class Temperature
{
    public static int $conversions = 0;

    public static function toFahrenheit(float $c): float
    {
        self::$conversions++;
        return $c * 9 / 5 + 32;
    }
}

echo Temperature::toFahrenheit(20), "\n";
echo Temperature::toFahrenheit(37.5), "\n";
echo 'Conversions so far: ', Temperature::$conversions, "\n";

There is no new Temperature() anywhere. Static members are useful for helpers that need no object state (conversions, factories, validation) and for data that belongs to the class as a whole, like a counter.

Static properties are shared by all objects

A normal property has one value per object. A static property has one value for the whole class, so every object sees the same one. Here each new User increments a shared counter and receives the next ID:

<?php
class User
{
    private static int $nextId = 1;
    public readonly int $id;

    public function __construct(public string $name)
    {
        $this->id = self::$nextId++;
    }

    public static function created(): int
    {
        return self::$nextId - 1;
    }
}

$a = new User('Ada');
$b = new User('Grace');
$c = new User('Linus');

echo "{$a->name} #{$a->id}, {$b->name} #{$b->id}, {$c->name} #{$c->id}\n";
echo User::created(), " users created\n";

Note the $ in self::$nextId: static properties keep it after ::, while constants (self::MAX) do not. A static property lives for one PHP request only. On a typical website (PHP-FPM or Apache) it starts over with every page load, so it is not a place to store data between visitors.

Static methods have no $this

A static method runs without an object, so $this does not exist inside it. A static method can call other static methods with self::, but it cannot read normal properties. Calling a normal method statically fails as well:

<?php
class Slug
{
    private string $separator = '-';

    public static function make(string $text): string
    {
        $text = strtolower(trim($text));
        return trim(preg_replace('/[^a-z0-9]+/', '-', $text), '-');
    }

    public function withSeparator(string $text): string
    {
        return str_replace('-', $this->separator, self::make($text));
    }
}

echo Slug::make('  Hello, Static World! '), "\n";
echo (new Slug())->withSeparator('Objects can call static methods'), "\n";

try {
    echo Slug::withSeparator('no object here');
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

The opposite direction is fine: a normal method can call static ones, as withSeparator() does with self::make().

self vs static: late static binding

self:: points to the class where the code is written. static:: points to the class the method was called on at runtime. The difference only shows up with inheritance, and it matters most for factory methods:

<?php
class Model
{
    public static function createWithSelf(): Model
    {
        return new self();
    }

    public static function createWithStatic(): static
    {
        return new static();
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }

    public static function tableWithSelf(): string
    {
        return strtolower(self::class) . 's';
    }
}

class Post extends Model {}
class Comment extends Model {}

echo get_class(Post::createWithSelf()), "\n";    // Model
echo get_class(Post::createWithStatic()), "\n";  // Post
echo Post::table(), ', ', Comment::table(), "\n";
echo Post::tableWithSelf(), "\n";

Post::createWithSelf() returns a Model, which is almost never what the caller wanted. static resolves to Post because that is the class named in the call; PHP calls this late static binding. Use static:: and new static() in methods meant to be inherited, and self:: when you really mean this exact class. The same rule applies to constants: static::TABLE picks up a child's own TABLE, while self::TABLE always reads the one in the class where the code is written.

Inherited static properties are shared

A child class shares its parent's static property unless it declares its own. This is the classic static surprise: two subclasses counting into one number.

<?php
class Counter
{
    public static int $count = 0;

    public static function increment(): void
    {
        static::$count++;
    }
}

class Apples extends Counter {}

class Pears extends Counter
{
    public static int $count = 0;   // its own copy
}

Apples::increment();
Apples::increment();
Pears::increment();

echo 'Counter: ', Counter::$count, "\n";
echo 'Apples: ', Apples::$count, "\n";
echo 'Pears: ', Pears::$count, "\n";

Apples has no $count of its own, so Apples::$count is Counter::$count, and both print 2. Pears redeclares the property and counts on its own. A static property declared in a trait behaves differently: each class using the trait gets a separate copy.

Static variables inside functions

static has a second meaning inside a function body: a static variable keeps its value between calls. The initial value is assigned only the first time the function runs:

<?php
function nextTicket(): string
{
    static $number = 0;
    $number++;
    return sprintf('T-%04d', $number);
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

// A simple cache: computed once, reused afterwards
function slowSquare(int $n): int
{
    static $cache = [];
    if (!isset($cache[$n])) {
        echo "(computing $n) ";
        $cache[$n] = $n * $n;
    }
    return $cache[$n];
}

echo slowSquare(12), "\n";
echo slowSquare(12), "\n";

The second slowSquare(12) skips the computation. Like static properties, these values reset at the end of each request. The variables page covers variable scope in general.

When static is the wrong choice

Static methods are convenient, and that makes them easy to overuse. A class whose methods all read and write static properties is global state with a class name on it: every caller shares it, tests cannot get a fresh copy, and you cannot swap in a different implementation.

<?php
// Static: one shared cart for the whole program
class StaticCart
{
    private static array $items = [];

    public static function add(string $item): void { self::$items[] = $item; }
    public static function items(): array { return self::$items; }
}

// Object: each cart is separate
class Cart
{
    private array $items = [];

    public function add(string $item): void { $this->items[] = $item; }
    public function items(): array { return $this->items; }
}

StaticCart::add('book');
StaticCart::add('pen');     // a "second customer" adds to the same cart
print_r(StaticCart::items());

$ada = new Cart();
$linus = new Cart();
$ada->add('book');
$linus->add('pen');
print_r($ada->items());
print_r($linus->items());

Good uses of static: pure helpers with no state (Slug::make()), named constructors (Color::fromHex()), and class-wide constants. If a method needs data that could differ between two uses, it wants an object.