Exploring Late Static Binding in PHP

🧠 PHP Late Static Binding Explained: self:: vs static:: vs new static() for Real-World Use

Hey fellow devs,

Ever found yourself confused by the difference between self::, static::, new self() and new static() in PHP?

I did too. Until I slowed down, played with examples, and finally understood the beauty of something called Late Static Binding (LSB).

Let’s break it down like we’re talking over a project debug session.

🤔 What’s the Problem?

You have a parent class that defines a static method. You extend it with a child class and call the method from the child. But surprisingly, the method behaves like it’s still running in the parent.

Like this:

class ParentClass {
    public static function whoAmI() {
        echo "I am " . self::class;
    }
}

class ChildClass extends ParentClass {}

ChildClass::whoAmI(); // ❌ Output: I am ParentClass

Why did it say ParentClass? You called it from ChildClass, right?

Because self:: refers to the class where the method is defined, not who called it.

And that's the limitation Late Static Binding solves.

🛠 Enter: static:: — the Fix

class ParentClass {
    public static function whoAmI() {
        echo "I am " . static::class;
    }
}

class ChildClass extends ParentClass {}

ChildClass::whoAmI(); // ✅ Output: I am ChildClass

That’s it! With static::, PHP waits until runtime to figure out which class is calling. Hence the term late binding.

🧪 self::class vs static::class

This is especially powerful in patterns like factories or service locators.

🎭 Object Creation: new self() vs new static()

Let’s create objects and see the difference:

class Animal {
    public static function create() {
        return new static(); // 👈 creates the calling class
    }
}

class Dog extends Animal {}
class Cat extends Animal {}

$dog = Dog::create(); 
$cat = Cat::create();

echo get_class($dog); // Dog ✅
echo get_class($cat); // Cat ✅

• new static() → respects the child class
• new self() → would have returned Animal in both cases ❌

So again...

🔌 Real Use Case (Like in a Plugin)

Imagine you're building a WordPress plugin with multiple shortcode handlers. You could create a BaseShortcode like this:

class BaseShortcode {
    public static function init() {
        echo "Booting: " . static::class . "\n";
        return new static(); // 🎯
    }
}

class GalleryShortcode extends BaseShortcode {}
class FormShortcode extends BaseShortcode {}

$g = GalleryShortcode::init(); // GalleryShortcode
$f = FormShortcode::init();    // FormShortcode

If you had used new self() and self::class, both would have printed BaseShortcode. Not what you want when building reusable code, right?

🧠 Think of It Like This

• self:: / new self() → fixed, bound to the class that wrote the method
• static:: / new static() → flexible, bound to the class that called the method

Late static binding gives your OOP code dynamic power while keeping it clean.

🧪 Practice Time

Can you make this code output:

Creating UserController

👉 Try replacing what’s needed:

class BaseController {
    public static function load() {
        echo "Creating " . ???;
        return ???;
    }
}

class UserController extends BaseController {}

$ctrl = UserController::load();

(Answer: replace ??? with static::class and new static() 😉)

🧵 Final Thoughts

Late static binding might sound fancy, but it's just a tool that lets your code act more like real-world behavior: flexible, extendable, and smart at runtime.

When you’re building reusable components, plugin frameworks, or Laravel-style factories — understanding this makes your OOP code next level.