Class constants are public by default and can be controlled with visibility modifiers: 1. public allows access from anywhere, 2. protected restricts access to the class and its subclasses, 3. private limits access to the defining class only; they are inherited but resolution depends on self:: (early binding) or static:: (late static binding), and using final in PHP 8.1 prevents overriding, enhancing class design predictability and maintainability.

Class constants are a fundamental feature in object-oriented programming, especially in languages like PHP and Java. They allow you to define values that remain unchanged throughout the execution of your program. But to use them effectively, you need to understand how visibility, inheritance, and the final modifier affect their behavior.

Let’s break down each of these concepts with practical insights.

1. Visibility of Class Constants

By default, class constants are public in most languages (like PHP and Java), meaning they can be accessed from anywhere — inside the class, in child classes, and from outside code.

In PHP, you can explicitly set visibility:

class MathUtils {
    public const PI = 3.14159;
    protected const MAX_VALUE = 1000;
    private const SECRET = 'hidden';
}

• public → Accessible everywhere.
• protected → Only accessible within the class and its subclasses.
• private → Only accessible within the defining class.

Example:

class Child extends MathUtils {
    public function showConstants() {
        echo self::PI;        // OK
        echo self::MAX_VALUE; // OK (protected)
        // echo self::SECRET; // Error! (private)
    }
}

? Key Point: Visibility controls who can read the constant. Unlike properties, constants cannot be changed after definition — visibility only restricts access, not mutability.

2. Inheritance and Method Resolution

Class constants are inherited by child classes, just like methods and properties.

class Animal {
    public const SPECIES = 'Unknown';
    public function info() {
        echo static::SPECIES; // Late static binding
    }
}

class Dog extends Animal {
    public const SPECIES = 'Canine';
}

Calling Dog::SPECIES returns 'Canine', overriding the parent.

But here’s where it gets interesting: constant resolution depends on how you reference it.

• self::CONSTANT → Refers to the constant in the current class (early binding).
• static::CONSTANT → Uses late static binding, meaning it resolves to the called class (useful in inheritance).

Example:

echo Dog::info(); // Outputs: Canine

Because info() uses static::SPECIES, it refers to Dog’s version, not Animal’s.

?? Watch out: If you use self::SPECIES in the parent method, it would always return 'Unknown', even when called on Dog.

3. Using final to Prevent Constant Override

Sometimes, you want to make sure a constant cannot be redefined in child classes. That’s where the final modifier comes in — at least in PHP 8.1 .

class BankAccount {
    final public const TYPE = 'Standard';
}

class SavingsAccount extends BankAccount {
    // This will cause a Fatal error:
    // public const TYPE = 'Savings'; // ? Cannot override final constant
}

Before PHP 8.1, there was no way to make constants final. Now, you can lock them down.

? Use final on constants when their value is a core part of the class contract and must not change.

Note: Java doesn’t have an exact equivalent because all constants (defined with public static final) are implicitly final — you can’t override them at all. So this behavior varies by language.

Practical Tips

Here are a few best practices when working with class constants:

• ? Use private constants for internal magic numbers or strings.
• ? Prefer static:: over self:: when accessing constants in inherited methods.
• ? Mark critical constants as final (in PHP 8.1 ) to prevent accidental overrides.
• ? Don’t treat constants like configuration — if values change per environment, use config files or dependency injection.

Basically, class constants aren’t just static values — their behavior changes based on visibility, inheritance rules, and modifiers like final. Understanding these nuances helps you design more predictable and maintainable class hierarchies.

The above is the detailed content of Mastering Class Constants: Visibility, Inheritance, and `final` Modifiers. For more information, please follow other related articles on the PHP Chinese website!