.PHP File Format – Classes

Declaration

[#[attribute]] {abstract | final | readonly} class Name [extends Parent] [implements Interface {, Interface}]
{
    {constant | property | method | use Trait; | case}
}

final class Point
{
    public const ORIGIN = [0, 0];

    public function __construct(
        public readonly int $x = 0,
        public readonly int $y = 0,
    ) {}

    public function distanceTo(self $other): float
    {
        return hypot($this->x - $other->x, $this->y - $other->y);
    }
}

$p = new Point(3, 4);
echo $p->distanceTo(new Point());  // 5

• A class name is case-insensitive, and shares a namespace with interfaces, traits and enums. It cannot be a reserved word.
• A class extends at most one parent (extends), and may implement any number of interfaces.
• abstract stops a class being instantiated, and final stops it being extended.
• readonly class (PHP 8.2) makes every property readonly. See Readonly classes.
• $a->b accesses a member of an object. Inside a method $this is the object, and a member must be reached through $this; there is no implicit member scope. Foo::class and $obj::class (PHP 8.0) give the class name as a string.
• A class with no parent or interfaces, declared at the top level of a file, can be used before its declaration. In other cases do not rely on it: put the declaration first or use autoloading.

Properties

{modifier} [type] $name [= constant-expression] ;
{modifier} [type] $name [= default] { hooks }

• A property without a visibility modifier is public, as with var, static or readonly alone.
• A default must be a constant expression. new is not allowed in a property default.
• A typed property (PHP 7.4) with no default is uninitialised. Reading it throws Error. An untyped property with no default is null.
• A property type cannot be void, never or callable. Types are invariant when overriding.
• Reading an undefined property gives a warning (a notice before 8.0) and null.

class Person
{
    public string $name {
        set => ucfirst(strtolower($value));   // short set: the result is stored
    }

    public string $first {
        get => explode(' ', $this->name)[0];  // virtual: no storage of its own
    }

    public int $age = 0 {
        get { return $this->age; }
        set(int|string $value) {               // wider than the property type
            $this->age = (int) $value;
        }
    }
}

Class constants

class Http
{
    public const OK = 200;
    protected const NOT_FOUND = 404;
    final public const string NAME = 'http';  // typed, PHP 8.3
}

echo Http::OK;

• A constant is defined once per class, is public by default, and is read with Class::NAME, self::NAME or static::NAME.
• The value is a constant expression, which may refer to other constants.
• final constants (PHP 8.1) cannot be redefined by a child. Interface constants can be overridden since 8.1.
• Typed constants (PHP 8.3) are declared after the modifiers.
• Foo::{$name} fetches a constant by name at run time (PHP 8.3). constant() does the same for a string.

Methods

{abstract | final | static | visibility} function [&] name ( parameters ) [: type] { statements }

• A method is called with $obj->m(), or on the class with Foo::m() if static. Method names are case-insensitive.
• An overriding method must be compatible with the parent: covariant return type, contravariant parameter types, same or wider visibility, and no new required parameter. __construct() is exempt. A failure is a compile error.
• An abstract method has no body and a final method cannot be overridden. Private methods cannot be final, except __construct().
• #[\Override] (PHP 8.3) makes a method declare that it overrides, so that a typo or removed parent method is a compile error.
• A static method has no $this. Calling one through an object is allowed. Calling an instance method statically throws Error since PHP 8.0.

Visibility

Access is checked against the class of the code, not the object. A private property redeclared in a child is a separate property. Visibility can be widened in a child but not narrowed. Methods with no modifier are public. Class constants have had visibility since PHP 7.1.

Constructors and destructors

__construct() runs on each new object. A parent’s constructor runs only if the child calls parent::__construct(), or defines no constructor of its own. Before PHP 8.0 a method named after its class could act as a constructor. In 8.0 it became an ordinary method.

class Money
{
    public function __construct(
        public readonly int $amount,
        protected string $currency = 'GBP',
    ) {}
}

Static members

A static property or method belongs to the class. Inside the class, use self:: for the current class, parent:: for the parent and static:: for the class actually called. $obj::$prop and $className::method() work with a value on the left.

class Model {
    public static function create(): static { return new static(); }
    public static function name(): string   { return static::class; }
}

class User extends Model {}

echo get_class(User::create());   // User
echo User::name();                // User

Magic methods

Methods whose names start with two underscores are reserved. These are called by the engine (manual). All must be public except __construct(), __destruct() and __clone(). If declared types are used, they must match the documented signature.

Overloading methods are called only for names that cannot be accessed from the current scope. They cannot take arguments by reference. Inside __get(), using the same undefined property does not call __get() again.

Cloning

clone $x creates a copy of an object and, if the class has one, runs __clone() on the copy. The copy is shallow: properties holding objects still refer to the same objects, so __clone() usually clones those itself.

class Doc {
    public DateTime $date;
    public function __clone(): void { $this->date = clone $this->date; }
}

$copy = clone $original;

Since PHP 8.5 clone may also be called as a function with an array of properties to change on the copy. Those are set after __clone(), respect visibility, and work on readonly properties:

readonly class Colour {
    public function __construct(public int $r, public int $g, public int $b) {}
    public function withGreen(int $g): static { return clone($this, ['g' => $g]); }
}

Enum cases cannot be cloned. Comparing objects: == is true if both are instances of the same class with equal properties, and === only if they are the same instance.

Anonymous classes

new class (args) extends Base implements I { … } (PHP 7.0) declares a class in an expression. Every run of the same declaration creates an object of the same class. Its name is generated by the engine and should not be used. A surrounding class’s private members are not automatically accessible inside it. Pass values in through the constructor.

Lazy objects

Since PHP 8.4 the Reflection API can create objects whose initialisation is deferred until first use, with ReflectionClass::newLazyGhost() and ReflectionClass::newLazyProxy(). This is a run-time feature with no syntax of its own.