Entendendo Constantes OOP em PHP

Uma constante de classe é um valor fixo e nomeado que pertence a uma classe, e não a um único objeto. Ela é definida uma vez, nunca pode ser reatribuída em tempo de execução e é compartilhada por cada instância da classe. As constantes são a forma de dar nomes significativos aos valores "mágicos" dos quais seu código depende — uma taxa de imposto, uma string de status, uma versão de API — para que eles existam em um único lugar, em vez de ficarem espalhados como literais.

Este capítulo aborda como declarar constantes de classe com const, como lê-las com self, static e o nome da classe, como controlar sua visibilidade e como elas se comportam com herança e interfaces. Todos os exemplos abaixo funcionam em PHP 8.

Por que usar constantes de classe?

Use uma constante de classe quando um valor é conhecido antecipadamente e nunca deve mudar enquanto o script executa:

Fonte única da verdade. Defina um valor como Order::SHIPPING_FEE uma vez; cada chamador lê o mesmo número.
Legibilidade. Circle::PI diz muito mais do que um simples 3.14159 enterrado em um cálculo.
Segurança. O PHP rejeita qualquer tentativa de reatribuir uma constante, portanto um erro de digitação não pode sobrescrevê-la silenciosamente.
Nenhum objeto necessário. Como uma constante pertence à classe, você pode lê-la sem criar uma instância.

As constantes de classe diferem das variáveis regulares de duas maneiras importantes: elas são escritas sem cifrão (MAX_USERS, não $MAX_USERS), e são imutáveis uma vez definidas.

Definindo uma constante de classe

Declare uma constante dentro do corpo da classe com a palavra-chave const, um nome (convencionalmente em UPPER_SNAKE_CASE) e um valor:

<?php

class MyClass {
    const CONSTANT = 'constant value';

    public function showConstant() {
        echo self::CONSTANT . "\n";
    }
}

Isso define CONSTANT em MyClass. Uma constante de classe não é o mesmo que uma constante global criada com define(): const pertence à classe e é acessada através de ::, enquanto define() registra um nome no escopo global.

O valor pode ser uma expressão constante — um cálculo que o PHP pode resolver em tempo de compilação — e até mesmo um array:

<?php

class Circle {
    const PI = 3.14159;
    const TWO_PI = self::PI * 2; // built from another constant
    const UNITS = ['mm', 'cm', 'm'];
}

echo Circle::TWO_PI . "\n";   // 6.28318
echo Circle::UNITS[1] . "\n"; // cm

O que você não pode usar é qualquer coisa conhecida apenas em tempo de execução — chamadas de função, instâncias de objetos ou $variáveis não são permitidas no valor de uma constante.

Acessando uma constante de classe

A forma de ler uma constante depende de onde você está:

De fora da classe, use o nome da classe: MyClass::CONSTANT.
De dentro da classe, use a palavra-chave self: self::CONSTANT.

php— editable, runs on the server

constant value
constant value

A primeira linha lê a constante estaticamente pelo nome da classe — nenhum objeto necessário. A segunda passa por um método de instância que usa self::CONSTANT. Note que você acessa constantes com ::, nunca com o operador de objeto -> que você usa para propriedades.

Controlando a visibilidade

Desde o PHP 7.1, as constantes de classe aceitam os mesmos modificadores de visibilidade que propriedades e métodos: public (o padrão), protected e private. Isso permite ocultar detalhes de implementação que pertencem à classe, mas não devem ser lidos de fora.

<?php

class Config {
    public const VERSION = '2.0';
    protected const API_KEY = 'secret-123';
    private const SALT = 'x9f2';

    public function describe(): string {
        return self::VERSION . ' / ' . self::API_KEY . ' / ' . self::SALT;
    }
}

echo Config::VERSION . "\n"; // 2.0 — public, readable anywhere
$c = new Config();
echo $c->describe() . "\n";  // 2.0 / secret-123 / x9f2

Aqui Config::VERSION é acessível em qualquer lugar, enquanto API_KEY e SALT só podem ser acessados de dentro da classe (ou, no caso de protected, suas subclasses). Tentar ler Config::SALT de fora gera um erro.

Constantes e herança

Subclasses herdam as constantes de seus pais e podem substituí-las. A palavra-chave que você usa para ler a constante decide qual versão você obtém:

self::NAME é resolvido quando o código é escrito — sempre significa a constante na classe onde o método está definido.
static::NAME é resolvido em tempo de execução em relação à classe real que foi chamada. Isso é chamado de late static binding.

<?php

interface HasStatus {
    const ACTIVE = 'active'; // interface constants are always public
}

class Order implements HasStatus {
    const SHIPPING_FEE = 5.00;

    public function status(): string {
        return self::ACTIVE;
    }
}

class ExpressOrder extends Order {
    const SHIPPING_FEE = 15.00;

    public function fee(): float {
        return static::SHIPPING_FEE; // uses the called class's value
    }
}

echo Order::ACTIVE . "\n";              // active (inherited from the interface)
echo (new ExpressOrder())->fee() . "\n";    // 15
echo (new ExpressOrder())->status() . "\n"; // active

Interfaces também podem declarar constantes; elas são implicitamente public e compartilhadas por cada classe implementadora. Se você precisar de uma constante que as subclasses não devem substituir, marque-a como final (PHP 8.1+): final const ID = 100;. O PHP 8.3 também adicionou constantes tipadas, por exemplo const string LABEL = 'base';.

Para mais informações sobre o comportamento de subclasses, consulte PHP Inheritance, e para o recurso de dados em nível de classe relacionado, PHP Static Properties.

Armadilhas comuns

Sem cifrão. const RATE = 0.2; — escrever $RATE é um erro de sintaxe.
::, não ->. As constantes são sempre acessadas com o operador de resolução de escopo.
Valores em tempo de execução são rejeitados. O valor de uma constante deve ser uma expressão constante; const NOW = time(); não vai compilar.
self vs static. Use static:: quando você pretende que uma subclasse possa substituir o valor; caso contrário, self:: é a escolha mais segura e previsível.

Conclusão

As constantes de classe fornecem valores nomeados, imutáveis e com escopo de classe, definidos com const e lidos através de ::. Use-as para centralizar valores fixos, melhorar a legibilidade e bloquear dados que nunca devem mudar em tempo de execução. Combine-as com modificadores de visibilidade para ocultar aspectos internos e lembre-se da distinção entre self e static quando a herança entrar em cena.

Prática

O que é verdadeiro sobre as Constantes de Classe PHP de acordo com o link: https://www.w3docs.com/learn-php/php-class-constants.html?

Constantes de classe são definidas dentro da definição da classe e fora dos métodos.Você pode alterar o valor de uma Constante de Classe PHP depois de definida.Uma constante de classe pode ser acessada usando o duplo dois-pontos (::).Uma constante de classe é sempre sensível a maiúsculas e minúsculas.Uma constante de classe só pode ser definida dentro de métodos.