Late static binding controla qual classe é referenciada em contextos estáticos dentro da herança. A distinção-chave: self:: refere-se à classe onde o código é escrito, enquanto static:: refere-se à classe que foi realmente — o que importa quando uma classe filha herda um método estático da classe pai.
<?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:: é resolvido no momento da definição (sempre a classe definidora), então mesmo quando chamado via ChildClass, new self() cria uma ParentClass. static:: é resolvido em tempo de execução para a classe realmente chamada — então new static() cria corretamente uma ChildClass.
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 é o que torna os métodos factory herdados, fluent builders e padrões ORM retornam a instância correta de subclasse — essencial para as APIs baseadas em método estático que os frameworks dependem.
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::) é um conceito PHP importante e frequentemente mal compreendido, particularmente relevante para entender como os frameworks implementam APIs estáticas baseadas em herança.
A distinção crucial — que self:: liga-se à classe onde o código é escrito enquanto static:: liga-se à classe realmente chamada em tempo de execução — importa sempre que uma classe filha herda um método estático da classe pai que cria instâncias ou referencia a classe: com self::, os métodos factory herdados sempre retornariam o tipo de classe pai (um bug), enquanto static:: corretamente retorna a subclasse chamada.
Isso é exatamente o que permite os métodos factory herdados, fluent builders e padrões ORM que frameworks como o Eloquent do Laravel dependem (por exemplo, User::make() retorna um User, não a base Model).
Compreender late static binding é importante tanto para usar esses padrões de framework corretamente quanto para escrever seus próprios métodos estáticos conscientes de herança que se comportam adequadamente com subclasses.
Embora um tópico mais avançado, é uma fonte comum de bugs sutis e confusão ("por que isso está retornando a classe pai?"), e entender a distinção self::/static::/parent:: reflete conhecimento mais profundo do modelo de objetos do PHP e do comportamento de herança — valioso para trabalhar com e construir as APIs baseadas em método estático, pesadas em herança, comuns em frameworks PHP modernos.