skip to content

In PHP, what rules govern a trait's abstract methods, static members, properties and constants once the trait is used by several classes?

level: middleimportance: should knowfreq 32%

answer

  1. abstract methods: signatures checked since 8.0
  2. static state per using class
  3. calling static on the trait is deprecated
  4. same property: must be identical
  5. trait constants 8.2, not via trait name

basics

~20 s

Abstract trait methods are requirements the host must implement compatibly. Static state exists once per using class, not per trait. A host may redeclare a trait property or constant only identically, and trait constants (8.2) and static members are used through the using class.

solid answer

~50 s

An **abstract method** in a trait is a requirement on the host class; since PHP 8.0 the host's implementation must follow the signature compatibility rules, and it may be `private`. **Static members** belong to each using class: `Article::$instances` and `Page::$instances` are separate, a `static $count` inside a trait method counts per class, and since PHP 8.3 a subclass that uses the trait again gets its own static property instead of sharing the parent's. Calling a static method or reading a static property **on the trait itself** is deprecated since 8.1 and emits `E_DEPRECATED`. A host may redeclare a trait **property** only with an identical definition, otherwise the class fails with `... define the same property ... However, the definition differs`. **Constants**, allowed in traits since 8.2, follow the same rule (visibility, value, finality) and cannot be read as `Trait::NAME`: `Cannot access trait constant ... directly`.

code

php · 28 lines
php
<?php
declare(strict_types=1);

trait Counts
{
    public static int $created = 0;
    public const LABEL = 'entity';

    public static function track(): int
    {
        return ++static::$created;
    }
}

final class Article { use Counts; }
final class Page { use Counts; }

Article::track();
Article::track();
Page::track();

echo Article::$created, ' ', Page::$created, ' ', Article::LABEL, "\n"; // 2 1 entity

try {
    echo Counts::LABEL;
} catch (Error $e) {
    echo $e->getMessage(), "\n"; // Cannot access trait constant Counts::LABEL directly
}

go deeper

for a junior

Recall that traits can declare abstract methods, static members, properties and, since PHP 8.2, constants, and that you use them through the class that uses the trait.

for a middle

Explain per-class static state, the compatibility rule for redeclared properties and constants, the 8.1 deprecation of static access on traits and the 8.3 per-child static property change.

for a senior

Use abstract methods to make a trait's dependencies explicit, keep trait state private, and avoid designs that rely on static state being shared through a trait.

for a principal

Set rules for what state traits may carry in a shared codebase, given that each using class gets its own copy and hosts cannot vary the definitions.

## Abstract methods: requirements on the host A trait often needs something from the class that uses it, for example the current time or a table name. Declaring an **abstract method** makes that requirement explicit: ```php trait SoftDeletes { abstract protected function now(): DateTimeImmutable; } ``` Rules for abstract trait methods: - The host (or one of its parents, or another trait) must provide a concrete method with that name. - Since **PHP 8.0**, the implementation must follow the **signature compatibility** rules; before 8.0 the signature was not checked. - Abstract trait methods may be `public`, `protected` or `private`. Private abstract methods are legal only in traits. - An abstract method never collides with a concrete method of another trait; the concrete one satisfies it. ## Static members: per using class Because trait members are composed into each class, **static state is per class**, not per trait: 1. A `static $count` variable inside a trait method is separate in each class using the trait: two classes calling it once each both see `1`. 2. A static property declared in a trait exists separately on each using class. 3. Since **PHP 8.3**, if a child class uses the same trait again, its static property is distinct from the one in the parent class; before 8.3 they were shared across the hierarchy. 4. Calling a static method or accessing a static property **directly on the trait** (`SoftDeletes::purgeAll()`) has been deprecated since **PHP 8.1**, with `E_DEPRECATED: Calling static trait method SoftDeletes::purgeAll is deprecated, it should only be called on a class using the trait`. Call it on the using class instead. ## Properties: compose, never redefine differently A trait may declare properties, which become properties of each using class. If the class also declares a property with the same name, PHP accepts it only when the two definitions are **compatible**: same visibility, same type, same `readonly` modifier and same initial value. Anything else fails at declaration: `SoftDeletes and Article define the same property ($deletedAt) in the composition of Article. However, the definition differs and is considered incompatible. Class was composed` In practice, the host should not redeclare trait properties at all; if it needs a different default, set it in the constructor. ## Constants: since PHP 8.2 Traits may declare constants since **PHP 8.2**, including `final` ones. They follow two rules: | Rule | Consequence | |---|---| | read through the using class | `Article::PURGE_AFTER_DAYS` works; `SoftDeletes::PURGE_AFTER_DAYS` throws `Error: Cannot access trait constant SoftDeletes::PURGE_AFTER_DAYS directly` | | host redeclaration must be compatible | same visibility, same value and same finality, otherwise `... define the same constant ... considered incompatible` | ## A CMS soft-delete trait, end to end A `SoftDeletes` trait for CMS entities might combine all four: - `private ?DateTimeImmutable $deletedAt = null;` stores the flag in each entity. - `abstract protected function now(): DateTimeImmutable;` makes each entity provide the clock, which keeps tests deterministic. - `public const PURGE_AFTER_DAYS = 30;` documents the retention period, read as `Article::PURGE_AFTER_DAYS`. - A `public static function purgeCandidates()` helper is always called on the entity class, never on the trait, and any static cache it uses is separate for `Article` and `Page`. ## Why these rules exist All of them follow from **composition**: a trait is not an object or a type with its own storage, so its static state, constants and properties only exist inside the classes that use it. Accessing them through the trait name made sense only under a different model, which is why PHP deprecated or forbade it.

  • Why is a private abstract method useful in a trait?
    It lets the trait require a helper from the host without forcing that helper into the host's public or protected API. The trait's own methods call it through `$this`, and because the trait is composed into the host, the private method is accessible to them.
  • Before PHP 8.3, what went wrong when both a parent class and its child used a trait with a static property?
    The child shared the parent's static property, so incrementing a counter through one class changed it for the other. Since PHP 8.3 a child class that uses the trait again gets its own distinct static property, matching the per-class model everywhere else.

saying these in an interview costs you the question

  • A static property declared in a trait is shared by every class that uses it
  • Trait::CONSTANT is the normal way to read a trait constant
  • A class may redeclare a trait property with a different default value
  • Abstract methods in a trait may be implemented with any signature
  • Calling a static method on the trait name is fully supported