Constants in classes in PHP - Deep Dive

Overview - Constants in classes

What is it?

Constants in classes are fixed values defined inside a class that cannot change during the program. They are like labels with a value that stays the same for every object of that class. You access them without creating an object, using the class name. Constants help keep important values safe and easy to use throughout your code.

Why it matters

Constants in classes exist to store values that should never change, like configuration settings or fixed options. Without them, programmers might accidentally change important values, causing bugs or inconsistent behavior. They make code safer, clearer, and easier to maintain by giving a single source of truth for fixed values.

Where it fits

Before learning constants in classes, you should understand basic PHP classes and variables. After this, you can learn about static properties and methods, which also belong to the class rather than objects. Later, you might explore advanced topics like class inheritance and how constants behave with child classes.

Mental Model

Core Idea

A class constant is a fixed value stored inside a class that never changes and is shared by all instances.

Think of it like...

Imagine a classroom where the room number is written on the door. No matter who enters or leaves, the room number stays the same and everyone knows it. The room number is like a class constant—fixed and shared by all students.

┌─────────────────────────────┐
│          Class              │
│ ┌─────────────────────────┐ │
│ │ CONSTANT_NAME = VALUE    │ │
│ └─────────────────────────┘ │
│                             │
│ Access with ClassName::CONSTANT_NAME
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What are class constants

Concept: Introduce the idea of constants inside classes as fixed values.

In PHP, you can define a constant inside a class using the keyword 'const'. For example: class Car { const WHEELS = 4; } This means every Car has 4 wheels, and this value cannot change.

Result

The constant WHEELS is set to 4 and cannot be modified.

Understanding that constants are fixed values helps prevent accidental changes and keeps important data safe.

2

Foundation

Accessing class constants

Concept: Learn how to use class constants without creating objects.

You access a class constant using the class name, two colons, and the constant name: echo Car::WHEELS; // outputs 4 You do not need to create a Car object to get this value.

Result

The output is 4, showing direct access to the constant.

Knowing that constants belong to the class itself, not instances, saves memory and simplifies code.

3

Intermediate

Constants vs static properties

🤔Before reading on: do you think class constants can be changed like static properties? Commit to your answer.

Concept: Compare constants with static properties to understand immutability.

Static properties can change during runtime: class Car { public static $color = 'red'; } Car::$color = 'blue'; // allowed But constants cannot be changed once set: class Car { const WHEELS = 4; } Car::WHEELS = 5; // error Constants are always fixed, static properties are not.

Result

Trying to change a constant causes an error, while static properties can be updated.

Understanding this difference helps choose the right tool for fixed vs changeable class data.

4

Intermediate

Constants with visibility modifiers

🤔Before reading on: do you think class constants can be private or protected? Commit to your answer.

Concept: Learn about visibility (public, private, protected) for constants introduced in PHP 7.1+.

Since PHP 7.1, you can set visibility for constants: class Car { public const PUBLIC_CONST = 'public'; protected const PROTECTED_CONST = 'protected'; private const PRIVATE_CONST = 'private'; } Public constants are accessible everywhere, protected only inside the class and subclasses, private only inside the class.

Result

Constants can have different access levels controlling where they can be used.

Visibility on constants helps encapsulate data and control access, improving code design.

5

Intermediate

Using class constants in expressions

Concept: Constants can be used in calculations or other constant expressions.

You can use constants to build other constants or in code: class Math { const PI = 3.14; const DOUBLE_PI = self::PI * 2; } echo Math::DOUBLE_PI; // outputs 6.28 Constants can refer to other constants using self:: or class name.

Result

Constants can be combined or calculated at compile time.

Knowing constants can build on each other allows more flexible and readable fixed values.

6

Advanced

Inheritance and overriding constants

🤔Before reading on: do you think child classes can change parent class constants? Commit to your answer.

Concept: Explore how constants behave with class inheritance and overriding.

Child classes can define constants with the same name as parents: class Vehicle { const WHEELS = 4; } class Motorcycle extends Vehicle { const WHEELS = 2; } echo Vehicle::WHEELS; // 4 echo Motorcycle::WHEELS; // 2 Constants are not changed but shadowed in child classes.

Result

Child classes can have their own constants with the same name, hiding parent constants.

Understanding constant shadowing prevents confusion about which value is used in inheritance.

7

Expert

Late static binding with class constants

🤔Before reading on: does using self:: or static:: affect which constant is accessed? Commit to your answer.

Concept: Learn how late static binding changes constant resolution in inheritance.

Using self::CONSTANT always refers to the class where the code is written. Using static::CONSTANT refers to the called class at runtime. Example: class A { const VALUE = 'A'; public static function show() { echo self::VALUE; // always 'A' echo static::VALUE; // depends on caller } } class B extends A { const VALUE = 'B'; } B::show(); // outputs 'AB' static:: allows dynamic access to constants in inheritance.

Result

Late static binding lets child classes change which constant is used at runtime.

Knowing late static binding helps write flexible code that respects inheritance and overrides.

Under the Hood

Class constants are stored in the class's metadata by the PHP engine at compile time. They are immutable and accessed via a fixed memory address linked to the class name and constant identifier. When you use ClassName::CONSTANT, PHP looks up the constant in the class's constant table without creating an object. Visibility modifiers control access by checking the caller's context during runtime.

Why designed this way?

Constants were designed to provide a safe, efficient way to store fixed values tied to a class. Unlike variables, constants cannot change, preventing accidental bugs. Early PHP versions had only public constants, but visibility was added to improve encapsulation and align with properties and methods. Late static binding was introduced to solve inheritance issues where static calls needed dynamic resolution.

┌───────────────┐
│   PHP Engine  │
│ ┌───────────┐ │
│ │ ClassMeta │ │
│ │ ┌───────┐ │ │
│ │ │CONST  │ │ │
│ │ │TABLE  │ │ │
│ │ └───────┘ │ │
│ └───────────┘ │
│               │
│ Access: ClassName::CONST
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you change a class constant value after defining it? Commit to yes or no.

Common Belief: Class constants can be changed like normal variables if needed.

Reality: Class constants are immutable and cannot be changed once defined.

Why it matters: Trying to change a constant causes errors and breaks code assumptions about fixed values.

Quick: Are class constants accessible through object instances? Commit to yes or no.

Common Belief: You can access class constants using an object instance like $obj->CONSTANT.

Reality: Class constants must be accessed using the class name and scope resolution operator (::), not through objects.

Why it matters: Using objects to access constants causes syntax errors and confusion about ownership.

Quick: Does a child class modify the parent's constant when it defines a constant with the same name? Commit to yes or no.

Common Belief: Child classes override and change the parent's constant value globally.

Reality: Child classes define their own constant with the same name, shadowing but not changing the parent's constant.

Why it matters: Misunderstanding this leads to bugs when expecting parent constants to change unexpectedly.

Quick: Does using self:: and static:: always access the same constant? Commit to yes or no.

Common Belief: self:: and static:: behave the same when accessing class constants.

Reality: self:: accesses the constant in the current class, static:: uses late static binding to access the called class's constant.

Why it matters: Ignoring this difference causes unexpected behavior in inheritance and static method calls.

Expert Zone

1

Constants are resolved at compile time, so they cannot hold dynamic values or expressions that require runtime evaluation.

2

Using visibility on constants allows better encapsulation but can complicate inheritance and testing if overused.

3

Late static binding with constants can lead to subtle bugs if developers expect self:: and static:: to behave identically.

When NOT to use

Do not use class constants when you need values that change during execution; use static or instance properties instead. Avoid constants for large data structures or objects, as they only support scalar or array values. For configuration that varies by environment, consider external config files or environment variables.

Production Patterns

In production, class constants are often used for fixed configuration values, error codes, or option flags. They improve performance by avoiding repeated value creation. Developers use constants with namespaces and interfaces to organize shared fixed values. Late static binding is used in frameworks to allow flexible overrides of constants in child classes.

Connections

Immutable data structures

Class constants are a form of immutability within object-oriented programming.

Understanding immutability in data structures helps grasp why constants prevent accidental changes and improve reliability.

Functional programming constants

Both use fixed values that never change, promoting safer code.

Seeing constants in functional programming clarifies the universal benefit of fixed values across paradigms.

Mathematics: Constants in formulas

Class constants are like fixed numbers in math formulas that do not change.

Recognizing constants in math helps understand their role as unchanging anchors in programming logic.

Common Pitfalls

#1 Trying to change a class constant value after definition.

Wrong approach:

class Car {
const WHEELS = 4;
}
Car::WHEELS = 5; // attempt to change constant

Correct approach:

class Car {
const WHEELS = 4;
}
// Use the constant as is, do not assign a new value

Root cause:

Misunderstanding that constants are immutable and cannot be reassigned.

#2 Accessing class constants through object instances.

Wrong approach:

class Car {
const WHEELS = 4;
}
$car = new Car();
echo $car->WHEELS; // incorrect access

Correct approach:

class Car {
const WHEELS = 4;
}
echo Car::WHEELS; // correct access

Root cause:

Confusing constants with instance properties that require object access.

#3 Expecting child class constants to modify parent constants.

Wrong approach:

class Vehicle {
const WHEELS = 4;
}
class Bike extends Vehicle {
const WHEELS = 2;
}
// expecting Vehicle::WHEELS to be 2 now

Correct approach:

class Vehicle {
const WHEELS = 4;
}
class Bike extends Vehicle {
const WHEELS = 2;
}
// Vehicle::WHEELS remains 4, Bike::WHEELS is 2

Root cause:

Misunderstanding constant shadowing vs overriding.

Key Takeaways

Class constants are fixed values defined inside classes that cannot change during program execution.

You access class constants using the class name and :: operator, not through object instances.

Constants differ from static properties because they are immutable and often used for fixed configuration or options.

Visibility modifiers on constants control access and improve encapsulation starting from PHP 7.1.

Late static binding allows dynamic resolution of constants in inheritance, enabling flexible and reusable code.