El enlace estático tardío controla a qué clase se hace referencia en contextos estáticos dentro de la herencia. La distinción clave: self:: se refiere a la clase donde el código está escrito, mientras que static:: se refiere a la clase que realmente fue — lo que importa cuando una clase hija hereda un método estático de su padre.
<?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:: se resuelve en tiempo de definición (siempre la clase definidora), así que incluso cuando se llama a través de ChildClass, new self() crea una ParentClass. static:: se resuelve en tiempo de ejecución a la clase realmente llamada — así que new static() correctamente crea una 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
El enlace estático tardío es lo que hace que los métodos factory heredados, constructores fluidos y patrones ORM devuelvan la instancia de la subclase correcta — esencial para las APIs basadas en métodos estáticos en las que dependen los frameworks.
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)
El enlace estático tardío (static:: vs self::) es un concepto PHP importante y frecuentemente mal entendido, particularmente relevante para entender cómo los frameworks implementan APIs estáticas basadas en herencia.
La distinción crucial — que self:: se enlaza a la clase donde el código está escrito mientras que static:: se enlaza a la clase realmente llamada en tiempo de ejecución — importa siempre que una clase hija hereda un método estático de su padre que crea instancias o hace referencia a la clase: con self::, los métodos factory heredados siempre devolverían el tipo padre (un error), mientras que static:: correctamente devuelve la subclase llamada.
Esto es exactamente lo que permite los métodos factory heredados, constructores fluidos y patrones ORM en los que dependen frameworks como Laravel's Eloquent (p. ej. User::make() devolviendo un User, no el Model base).
Comprender el enlace estático tardío es importante tanto para usar estos patrones de framework correctamente como para escribir tus propios métodos estáticos conscientes de la herencia que se comporten adecuadamente con subclases.
Aunque es un tema más avanzado, es una fuente común de errores sutiles y confusión ("¿por qué esto devuelve la clase padre?"), y entender la distinción self::/static::/parent:: refleja un conocimiento más profundo del modelo de objetos de PHP y del comportamiento de herencia — valioso para trabajar con y construir las APIs basadas en métodos estáticos, con herencia intensiva comunes en los frameworks PHP modernos.