static

A palavra-chave static no PHP

A palavra-chave static no PHP tem dois usos distintos, e é útil separá-los desde o início:

1. Membros de classe — static marca uma propriedade ou método como pertencente à própria classe, e não a um objeto individual. Você o acessa sem criar uma instância, e todas as instâncias compartilham o mesmo valor.
2. Variáveis locais estáticas — dentro de uma função, static faz uma variável local manter seu valor entre chamadas, em vez de ser reiniciada a cada vez.

Este capítulo aborda os dois casos, além das palavras-chave relacionadas self, static:: e parent::, que você quase sempre encontra junto com membros estáticos. Se classes e objetos são novidade para você, leia Classes e Objetos primeiro.

Membros estáticos de classe

Uma propriedade normal existe em cada objeto. Uma propriedade estática existe na classe — há exatamente uma cópia, compartilhada por todas as instâncias e acessível mesmo quando nenhuma instância existe.

Sintaxe básica

<?php

class MyClass {
  public static $myProperty = "Hello, world!";

  public static function myMethod() {
    return self::$myProperty;
  }
}

Você lê um membro estático com o operador de resolução de escopo ::, não o operador de objeto ->:

<?php

echo MyClass::$myProperty;   // Hello, world!
echo MyClass::myMethod();    // Hello, world!

Dentro da classe, referencie seus próprios membros estáticos com self:: (ou static::, explicado abaixo) — nunca $this, pois um método estático pode ser executado sem nenhum objeto.

Para uma cobertura mais aprofundada, consulte Propriedades Estáticas e Métodos Estáticos.

Variáveis locais estáticas

A mesma palavra-chave faz algo completamente diferente dentro de uma função: ela faz uma variável persistir entre chamadas. Sem static, uma variável local é reinicializada a cada chamada; com ela, o valor inicial é definido uma vez e a variável mantém o que tinha na última vez.

<?php

function counter() {
  static $count = 0;   // initialised only on the first call
  $count++;
  return $count;
}

echo counter(); // 1
echo counter(); // 2
echo counter(); // 3

Isso é útil para armazenar em cache um resultado custoso ou contar quantas vezes uma função foi executada, sem expor uma variável global.

Exemplos

Vejamos alguns exemplos práticos de membros estáticos de classe:

Exemplos da palavra-chave static do PHP

<?php

// Example 1
class Counter
{
  public static $count = 0;

  public static function increment()
  {
    self::$count++;
  }
}

Counter::increment();
Counter::increment();
echo Counter::$count . PHP_EOL;

// Example 2
class User
{
  public static $name;

  public static function setName($name)
  {
    self::$name = $name;
  }
}

User::setName("John Doe");
echo User::$name;

Em Counter, a propriedade estática $count é compartilhada, então duas chamadas a increment() acumulam até 2. Em User, setName() armazena dados na própria classe, não em nenhum objeto.

self vs static (late static binding)

Quando você referencia um membro estático de dentro de um método, tem duas opções, e a diferença importa na herança:

• self:: é resolvido em tempo de compilação — sempre aponta para a classe onde o código está escrito.
• static:: usa late static binding — resolve em tempo de execução para a classe que foi realmente chamada.

<?php

class Base {
  public static function create() {
    return new static();   // runtime class
  }
  public static function createSelf() {
    return new self();     // always Base
  }
}

class Child extends Base {}

echo get_class(Child::create());     // Child
echo "\n";
echo get_class(Child::createSelf()); // Base

Use static:: quando uma subclasse deve poder substituir o comportamento ou ser a classe instanciada — o padrão acima é a base dos métodos factory. Use self:: quando você especificamente quer dizer esta classe. Para chamar um método estático do pai, use parent::. Consulte Herança para uma visão mais ampla.

Casos de uso comuns

• Contadores e estado compartilhado — um único valor rastreado entre todas as instâncias, como o Counter acima.
• Métodos utilitários / auxiliares — funções sem estado agrupadas em uma classe, ex.: Math::clamp(), chamados sem um objeto.
• Métodos factory — User::fromArray($data) retorna uma instância configurada; new static() mantém a compatibilidade com subclasses.
• Singletons e caches simples — uma propriedade estática guarda a única instância ou um resultado memoizado.

Para valores compartilhados imutáveis e nomeados, prefira uma constante de classe em vez de uma propriedade estática.

Armadilhas

• Sem $this em métodos estáticos. Um método estático pode ser chamado sem um objeto, então $this é indefinido ali. Acessar o estado de instância a partir de um método estático é um sinal de problema de design.
• Propriedades estáticas são estado compartilhado quase global. Como cada instância compartilha a mesma cópia, alterá-la de qualquer lugar afeta todos — é fácil introduzir acoplamento oculto e quebrar o isolamento de testes. Use com deliberação.
• :: para estático, -> para instância. MyClass::$prop (estático) vs $obj->prop (instância). Note que $ permanece no nome da propriedade na forma estática: Counter::$count, não Counter::count.
• Variáveis locais estáticas são por função, não por chamada. Duas chamadas recursivas compartilham a mesma variável static, o que às vezes surpreende.

Conclusão

A palavra-chave static tem dois papéis: define propriedades e métodos em nível de classe compartilhados entre todas as instâncias e acessíveis sem um objeto, e faz uma variável local de função sobreviver entre chamadas. Combine-a com self::, static:: e parent:: para controlar exatamente para qual classe suas chamadas estáticas são resolvidas. Use membros estáticos para estado genuinamente compartilhado e auxiliares sem estado — mas trate dados estáticos mutáveis compartilhados com o mesmo cuidado que trataria uma variável global.

Prática