Class Constants and self vs static in PHP

self vs static — what’s the difference?

• self:: refers to the class where the code is written. Binding happens at compile-time (early binding). It does not follow the calling class.
• static:: uses late static binding. It is resolved at runtime and points to the most derived class making the call (even if the code lives in the base class).
• parent:: refers to the immediate parent class.

• Want to “lock” reference to the current class (no polymorphism)? Use self::.
• Want dynamic, polymorphic references that support inheritance? Use static::.

PHP Code Examples

1) Defining and using class constants

class Status
{
    public const ACTIVE = 'active';
    protected const INTERNAL = 'internal';
    private const SECRET = 'xyz';

    public function printActive(): void
    {
        echo self::ACTIVE . PHP_EOL; // active
    }
}

echo Status::ACTIVE . PHP_EOL; // active
$status = new Status();
$status->printActive();

⚠️ Note: define() is not used for class constants — only const.

2) Inheritance and difference: self:: vs static:: for constants

class Base
{
    public const TYPE = 'base';

    public static function whoSelf(): void { echo self::TYPE . PHP_EOL; }
    public static function whoStatic(): void { echo static::TYPE . PHP_EOL; }
}

class Child extends Base
{
    public const TYPE = 'child';
}

Base::whoSelf();   // base
Base::whoStatic(); // base
Child::whoSelf();  // base (self:: binds to Base)
Child::whoStatic();// child (static:: late binding)

3) Static properties/methods with late static binding

class Counter
{
    protected static int $count = 0;

    public static function inc(): void { static::$count++; }
    public static function get(): int { return static::$count; }
}

class ChildCounter extends Counter
{
    protected static int $count = 0;
}

Counter::inc();
ChildCounter::inc();
echo Counter::get();     // 1
echo ChildCounter::get();// 1

If self::$count were used, both calls would affect the same property in Counter.

4) Factories: new static vs new self

class Model
{
    public static function make(): static { return new static(); }
    public static function makeSelf(): self { return new self(); }
}

class User extends Model {}

$u1 = User::make();
echo get_class($u1); // User
$u2 = User::makeSelf();
echo get_class($u2); // Model

• new static() supports polymorphism.
• new self() always instantiates the base class.

5) self::class vs static::class

class A
{
    public function debug(): void
    {
        echo 'self::class = ' . self::class . PHP_EOL;
        echo 'static::class = ' . static::class . PHP_EOL;
    }
}

class B extends A {}
(new B())->debug();
// self::class = A
// static::class = B

6) Visibility, final, typed constants

class Config
{
    public const string APP_NAME = 'Shop'; // typed constant (PHP 8.3+)
    protected const array DEFAULT_ROLES = ['user'];
    final public const int MAX_ITEMS = 100; // cannot be overridden
}

class ExtendedConfig extends Config
{
    // public const int MAX_ITEMS = 200; // ERROR: cannot override final constant
}

7) Constant vs static property

class Example
{
    public const VERSION = '1.0.0'; // constant, immutable
    public static bool $debug = false; // static, mutable
}

Best Practices and Common Mistakes

Best Practices