PHP OOP: Comprendiendo los Métodos Estáticos

Un método estático es un método declarado con la palabra clave static que pertenece a la clase en sí misma, en lugar de a algún objeto creado a partir de ella. Dado que está vinculado a la clase, puedes llamarlo directamente con el nombre de la clase y el operador de resolución de ámbito (::) — sin necesidad de new.

Este capítulo muestra cómo definir y llamar métodos estáticos, en qué se diferencian de los métodos regulares (de instancia), cómo se comportan self:: y static:: dentro de ellos, y los patrones donde los métodos estáticos son realmente útiles (utilidades, contadores y métodos de fábrica). Si eres nuevo con las clases, lee primero Clases y Objetos en PHP.

¿Qué son los métodos estáticos en PHP?

Los métodos regulares operan sobre un objeto específico y pueden leer sus datos de instancia a través de $this. Un método estático no tiene $this — no está vinculado a ninguna instancia, por lo que solo puede trabajar con los argumentos que le pasas y con los miembros estáticos propios de la clase.

Esto hace que los métodos estáticos sean ideales para operaciones sin estado: un cálculo que depende únicamente de sus entradas, no del estado de un objeto en particular. Calcular el promedio de una lista de números es un ejemplo clásico.

class Math
{
    public static function average(array $numbers): float
    {
        return array_sum($numbers) / count($numbers);
    }
}

¿Por qué usar métodos estáticos?

La desventaja: dado que los métodos estáticos no pueden ser sobrescritos a través de una referencia de objeto normal y no llevan estado de instancia, su uso excesivo dificulta la simulación y las pruebas unitarias del código. Prefiere los métodos de instancia cuando el comportamiento depende del estado del objeto.

Cómo definir y llamar un método estático

Añade static antes del nombre del método, y luego llámalo con ClassName::method():

<?php

class Math
{
    public static function average(array $numbers): float
    {
        return array_sum($numbers) / count($numbers);
    }
}

$average = Math::average([1, 2, 3, 4, 5]);
echo $average; // 3

El token :: es el operador de resolución de ámbito — el mismo operador que usas para las constantes de clase.

self:: vs static:: y la ausencia de $this

Dentro de un método estático no puedes usar $this, porque no hay ninguna instancia a la que referirse. Para acceder a otro miembro estático de la clase usas self:: o static::.

• self:: se resuelve en la clase donde el método está escrito.
• static:: usa el enlace estático tardío — se resuelve en la clase que fue realmente llamada en tiempo de ejecución, lo que importa con la herencia.

<?php

class Base
{
    public static function create(): string
    {
        return self::class;   // always "Base"
    }

    public static function make(): string
    {
        return static::class; // the called class
    }
}

class Child extends Base {}

echo Base::create(), "\n";  // Base
echo Child::create(), "\n"; // Base   (self:: is fixed to where it's written)
echo Child::make(), "\n";   // Child  (static:: follows the call)

Usa static:: cuando una clase padre define un comportamiento que las subclases deben poder redirigir hacia sí mismas — la base del patrón de fábrica que se muestra a continuación. Aprende más en Herencia en PHP.

Métodos estáticos con propiedades estáticas: un contador

Los métodos estáticos se combinan habitualmente con propiedades estáticas para mantener un estado compartido entre todos los objetos de una clase.

<?php

class User
{
    public static int $count = 0;

    public function __construct(public string $name)
    {
        self::$count++;
    }

    public static function total(): int
    {
        return self::$count;
    }
}

new User('Ada');
new User('Linus');

echo User::total(); // 2

Observa cómo total() lee self::$count sin un objeto — la propiedad vive en la clase, no en ningún User particular.

Métodos de fábrica

Un método estático que retorna una nueva instancia se llama método de fábrica. Proporciona una forma con nombre y legible para construir objetos:

<?php

class Temperature
{
    private function __construct(private float $celsius) {}

    public static function fromCelsius(float $c): static
    {
        return new static($c);
    }

    public static function fromFahrenheit(float $f): static
    {
        return new static(($f - 32) * 5 / 9);
    }

    public function celsius(): float
    {
        return $this->celsius;
    }
}

$t = Temperature::fromFahrenheit(212);
echo $t->celsius(); // 100

Usar new static() (enlace estático tardío) significa que una subclase que llame a fromCelsius() obtiene una instancia de sí misma, no de Temperature.

Errores comunes

• $this no está disponible. Usarlo dentro de un método estático provoca un error fatal — no existe ningún objeto actual.
• Los métodos estáticos e de instancia solo pueden compartir un nombre entre clases, no dentro de una misma clase. Dentro de una clase cada nombre de método es único.
• Puedes llamar un método estático sobre un objeto ($obj::method() o incluso $obj->method()), pero aún se ejecuta sin $this. Llamarlo con $obj-> está permitido pero puede llevar a confusión — prefiere ClassName::method() por claridad.
• El estado estático es global para el proceso. Un contador estático es compartido por todas las instancias y persiste durante toda la solicitud, lo que puede sorprenderte en código de larga duración o en pruebas.

Conclusión

Los métodos estáticos pertenecen a la clase, se ejecutan sin una instancia y no tienen acceso a $this. Brillan en utilidades sin estado, estado compartido a nivel de clase a través de propiedades estáticas, y métodos de fábrica que construyen objetos configurados. Usa self:: cuando te refieres a la clase que define el método y static:: cuando las subclases deben poder redirigir la llamada hacia sí mismas. Recurre a los métodos estáticos cuando el comportamiento está vinculado a la clase y no a un objeto en particular — y prefiere los métodos de instancia cuando no lo está.

A continuación, profundiza tu comprensión con Propiedades Estáticas en PHP y Constantes de Clase en PHP.

Práctica