PHP OOP: Entendendo Métodos Estáticos

Um método estático é um método declarado com a palavra-chave static que pertence à própria classe, e não a nenhum objeto criado a partir dela. Por estar vinculado à classe, você pode chamá-lo diretamente com o nome da classe e o operador de resolução de escopo (::) — sem necessidade de new.

Este capítulo mostra como definir e chamar métodos estáticos, como eles diferem dos métodos regulares (de instância), como self:: e static:: se comportam dentro deles, e os padrões em que os métodos estáticos realmente ajudam (utilitários, contadores e factory methods). Se você é novo em classes, leia PHP Classes e Objetos primeiro.

O que são métodos estáticos em PHP?

Os métodos regulares operam em um objeto específico e podem acessar seus dados de instância por meio de $this. Um método estático não possui $this — ele não está vinculado a nenhuma instância, portanto só pode trabalhar com os argumentos que você passa e com os membros estáticos da própria classe.

Isso torna os métodos estáticos adequados para operações sem estado: um cálculo que depende apenas de suas entradas, não do estado de um objeto específico. Calcular a média de uma lista de números é um exemplo clássico.

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

Por que usar métodos estáticos?

A contrapartida: como os métodos estáticos não podem ser sobrescritos por meio de uma referência de objeto normal e não carregam estado de instância, usá-los em excesso dificulta a simulação e os testes unitários do código. Prefira métodos de instância quando o comportamento depende do estado do objeto.

Como definir e chamar um método estático

Adicione static antes do nome do método e chame-o com 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

O token :: é o operador de resolução de escopo — o mesmo operador usado para constantes de classe.

self:: vs static:: e a ausência de $this

Dentro de um método estático você não pode usar $this, pois não há instância à qual se referir. Para acessar outro membro estático da classe, use self:: ou static::.

• self:: resolve para a classe onde o método está escrito.
• static:: utiliza late static binding — resolve para a classe que foi realmente chamada em tempo de execução, o que importa na herança.

<?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)

Use static:: quando uma classe pai define um comportamento que as subclasses devem ser capazes de redirecionar para si mesmas — a base do padrão factory abaixo. Saiba mais em Herança PHP.

Métodos estáticos com propriedades estáticas: um contador

Métodos estáticos são frequentemente combinados com propriedades estáticas para manter um estado compartilhado entre todos os objetos de uma classe.

<?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

Note como total() lê self::$count sem um objeto — a propriedade pertence à classe, não a nenhum User individual.

Factory methods

Um método estático que retorna uma nova instância é chamado de factory method. Ele oferece uma forma nomeada e legível de 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() (late static binding) garante que uma subclasse que chama fromCelsius() obtenha uma instância de si mesma, não de Temperature.

Armadilhas comuns

• $this não está disponível. Usá-lo dentro de um método estático gera um erro fatal — não há objeto atual.
• Métodos estáticos e de instância podem compartilhar um nome apenas entre classes, não dentro de uma mesma classe. Dentro de uma classe, cada nome de método é único.
• Você pode chamar um método estático em um objeto ($obj::method() ou até $obj->method()), mas ele ainda é executado sem $this. Chamá-lo com $obj-> é permitido, mas enganoso — prefira ClassName::method() para maior clareza.
• O estado estático é global para o processo. Um contador estático é compartilhado por todas as instâncias e persiste durante toda a requisição, o que pode surpreender em código de longa duração ou em testes.

Conclusão

Métodos estáticos pertencem à classe, são executados sem uma instância e não têm acesso a $this. Eles se destacam em utilitários sem estado, no estado compartilhado da classe por meio de propriedades estáticas e em factory methods que constroem objetos configurados. Use self:: quando se referir à classe onde o método está definido e static:: quando as subclasses precisarem redirecionar a chamada para si mesmas. Recorra a métodos estáticos quando o comportamento estiver vinculado à classe em vez de a um objeto específico — e prefira métodos de instância quando não for o caso.

A seguir, aprofunde seu entendimento com Propriedades Estáticas PHP e Constantes de Classe PHP.

Prática