PHP Academy · Aula

Propriedades e métodos estáticos

Use membros estáticos e entenda quando chamá-los sem uma instância.

Propriedades e métodos estáticos é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Introdução: Propriedades e Métodos Estáticos

Os membros estáticos pertencem à própria classe, e não a uma instância específica. Acesse-os com ClassName::member ou self:: dentro da classe. Eles são compartilhados por todas as instâncias.

Conceitos fundamentais

Conceitos fundamentais de propriedades e métodos estáticos:

Declare-os com a palavra-chave static
Acesse-os com :: (operador de resolução de escopo)
Use self:: dentro da classe e ClassName:: fora dela
Use a vinculação estática tardia com static::

Propriedade estática

Exemplo:

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Método estático

Continuação:

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Padrão de instância única

Prática:

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Contador estático

Aprofundamento:

<?php
class EventEmitter {
    private static int $instanceCount = 0;

    public function __construct() {
        self::$instanceCount++;
    }

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

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Vinculação estática tardia

Uso avançado:

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Fábrica estática

Padrão do mundo real:

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Estático versus instância: compromissos

Boas práticas:

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Padrão prático

Reunindo tudo em um padrão prático para propriedades e métodos estáticos.

Armadilhas comuns

Evite estes erros comuns com propriedades e métodos estáticos:

Os membros estáticos são compartilhados por todas as instâncias
Prefira a vinculação estática tardia (static::) a self:: em classes que podem ser herdadas
Instâncias únicas são um padrão comum, mas às vezes usado em excesso
Métodos estáticos são mais difíceis de simular em testes de unidade

Verificação rápida

Qual palavra-chave acessa uma propriedade estática dentro da classe, respeitando a herança (vinculação estática tardia)?

Recapitulação: Propriedades e Métodos Estáticos

Você estudou propriedades e métodos estáticos. Pontos principais para lembrar:

Os membros estáticos são compartilhados por todas as instâncias
Prefira a vinculação estática tardia (static::) a self:: em classes que podem ser herdadas
Instâncias únicas são um padrão comum, mas às vezes usado em excesso
Métodos estáticos são mais difíceis de simular em testes de unidade

Perguntas Frequentes

A aula “Propriedades e métodos estáticos” é grátis?

Sim — o texto completo de “Propriedades e métodos estáticos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Propriedades e métodos estáticos”?

Use membros estáticos e entenda quando chamá-los sem uma instância. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Propriedades e métodos estáticos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy