Late static binding (static:: vs self::) म्हणजे काय?

Question

Accepted Answer

**Late static binding** हे inheritance मध्ये static contexts मध्ये कोणता class reference केला जातो हे नियंत्रित करते. मुख्य फरक: **`self::`** कोड जिथे लिहिला आहे त्या class ला refer करते, तर **`static::`** runtime मध्ये जो class actually called केला गेला तो refer करते — जेव्हा child class ला parent class चा static method inherit असला तर यात फरक पडतो.

## समस्या: self:: हे "early bound" आहे

```php
<?php
class ParentClass {
    public static function create(): self {
        return new self();      // self:: ALWAYS means ParentClass (where it's written)
    }
    public static function createStatic(): static {
        return new static();    // static:: means the CALLED class (runtime)
    }
}

class ChildClass extends ParentClass {}

get_class(ChildClass::create());        // "ParentClass" — self:: bound to where written ❌
get_class(ChildClass::createStatic());  // "ChildClass" — static:: bound to the call ✅
```

`self::` definition time ला resolve होते (नेहमी defining class), म्हणून जरी `ChildClass` द्वारे called असला तरी, `new self()` हे `ParentClass` create करते. **`static::`** runtime ला actually-called class ला resolve होते — म्हणून `new static()` हे योग्यरित्या `ChildClass` create करते.

## महत्व का आहे: factory methods आणि fluent APIs

```php
class Model {
    public static function make(): static {     // static return type + new static()
        return new static();    // ✅ returns an instance of whatever subclass called it
    }
}
class User extends Model {}
class Post extends Model {}

User::make();   // returns a User (not a Model) — thanks to late static binding
Post::make();   // returns a Post
```

Late static binding हेच असे करते की inherited factory methods, fluent builders, आणि ORM patterns *सही subclass* instance return करतात — जे static-method-based APIs साठी essential आहे जिंचा frameworks वापर करतात.

## तीन keywords

```text
self::    → the class where the code is WRITTEN (early/static binding)
static::  → the class CALLED at runtime (late static binding) — for subclass-aware code
parent::  → the parent class (for calling overridden parent methods)
```

## महत्व का आहे

Late static binding (`static::` vs `self::`') हा एक महत्वाचा आणि वारंवार गैरसमज होणारा PHP concept आहे, विशेषतः frameworks कसे inheritance-based static APIs implement करतात हे समजण्यासाठी relevant आहे.

निर्णायक फरक — की **`self::` कोड जिथे लिहिला आहे तिथे bind होतो** तर **`static::` runtime मध्ये actually called class ला bind होतो** — हे तेव्हा महत्वाचे असते जेव्हा child class ला parent class चा static method inherit असतो जो instances create करतो किंवा class ला reference करतो: `self::` सह, inherited factory methods नेहमी parent type return करायचे (एक bug), तर **`static::` योग्यरित्या calling subclass return करतो**.

हेच असे करते की inherited factory methods, fluent builders, आणि ORM patterns जे Laravel चे Eloquent सारख्या frameworks वर अवलंबून असतात (उदा. `User::make()` एक `User` return करते, base `Model` नाही).

Late static binding समजणे दोन्ही या framework patterns योग्यरित्या वापरण्यासाठी आणि आपले स्वतःचे inheritance-aware static methods लिहिण्यासाठी महत्वाचे आहे जे subclasses सह योग्यरित्या काम करतात.

एक अधिक advanced topic असला तरी, हा subtle bugs आणि confusion चा सामान्य स्रोत आहे ("हे parent class का return करत आहे?"), आणि `self::`/`static::`/`parent::` फरक समजणे PHP च्या object model आणि inheritance behavior चे deeper knowledge प्रतिबिंबित करते — modern PHP frameworks मध्ये common असलेल्या static-method-based, inheritance-heavy APIs सह काम करण्यासाठी महत्वाचे.