#[Override] Attribute (PHP 8.3)

Also Known As

TL;DR

Explanation

In PHP before 8.3, you could write a method with the same name as a parent method and it would silently override it — or silently not override it if you misspelled the name. The #[Override] attribute makes the override intent explicit. When PHP loads a class with #[Override] on a method, it verifies that the method actually exists in a parent class or interface. If it doesn't — due to a rename, typo, or removed method — PHP throws an error immediately. This catches a class of silent bugs where a 'override' method is never called because it doesn't match the parent's signature.

Watch Out

Common Misconception

Why It Matters

Common Mistakes

• Not adding #[Override] to all override methods — it only helps if you use it consistently; adding it only sometimes gives false confidence.
• Confusing #[Override] with final — final prevents further overriding; #[Override] asserts that this method overrides something.
• Using #[Override] on methods that implement interface methods — this is valid and encouraged; interface method implementations count as overrides.
• Expecting #[Override] to validate signature compatibility — it only checks name existence, not parameter types or return types. Use PHPStan or Psalm for full signature checking.

Avoid When

• When a method is new to your class and does not override any parent method or interface contract — #[Override] will cause a load-time error.
• When working with dynamic or magic method patterns (__call, __get) where the 'override' relationship is intentionally implicit and not tied to a named parent method.
• When supporting legacy code where adding #[Override] to existing methods would require immediate refactoring of parent classes that cannot yet be updated.

When To Use

• You're refactoring a parent class and renaming or removing methods — mark all child implementations with #[Override] to catch accidental breaks in inheritance chains.
• You're working in a team where method names can be typo'd or misremembered — #[Override] turns silent bugs into immediate load-time errors that static analysers and CI pipelines will catch.
• You're maintaining a large codebase with deep inheritance hierarchies and need to document intent clearly — #[Override] makes it explicit that a method is intentional, not a leftover copy-paste.
• You're using a strict code standard or IDE that supports PHP 8.3+ attributes — applying #[Override] systematically improves type safety and refactoring confidence.

Code Examples

<?php
// ❌ Typo in override — silently creates a new method, parent's validate() runs
class UserValidator extends BaseValidator
{
    public function validae(mixed $data): bool // typo: validae not validate
    {
        return is_array($data) && isset($data['email']);
    }
    // BaseValidator::validate() still runs — this method is never called
}

<?php
// ✅ PHP 8.3 — #[Override] catches the typo at class load time
class UserValidator extends BaseValidator
{
    #[Override]
    public function validate(mixed $data): bool // PHP errors if validate() not in parent
    {
        return is_array($data) && isset($data['email']);
    }
}

// Also works with interface methods
class JsonRenderer implements RendererInterface
{
    #[Override]
    public function render(array $data): string
    {
        return json_encode($data, JSON_THROW_ON_ERROR);
    }
}

Tags

Related Terms

References

• https://www.php.net/releases/8.3/en.php