PHP Typed Properties, Readonly Classes & Property Hooks: Modern OOP

In modern PHP development, writing robust and maintainable code is paramount. One of the biggest leaps in that direction came with PHP 7.4's typed properties, which allow you to declare the exact type of data a class property can hold. No more guessing whether $user->name is a string or an object – the language enforces it at runtime. PHP 8.1 introduced readonly properties, which can only be assigned once, typically in the constructor, making immutable objects a breeze. And with PHP 8.4, property hooks are on the horizon, letting you add get/set logic directly on properties without writing separate methods. Together, these features transform how you design classes, making them more self-documenting, less error-prone, and easier to reason about. In this tutorial, you'll learn each feature inside out, see production-ready examples, and discover how to avoid common pitfalls. Whether you're building a simple DTO or a complex domain model, these tools will become your new best friends.

Typed Properties: The Basics

Typed properties allow you to declare the type of a class property. Supported types include scalar types (int, float, string, bool), arrays, iterable, object, mixed, and nullable types (prefixed with ?). You can also use class/interface names. Once declared, PHP will enforce that any value assigned to the property matches the type, throwing a TypeError if not. This catches bugs early and makes your code self-documenting.

Example: A simple User class with typed properties.

<?php

class User {
    public int $id;
    public string $name;
    public ?string $email = null;
    public array $roles = [];
}

$user = new User();
$user->id = 1;
$user->name = 'Alice';
$user->email = 'alice@example.com';
$user->roles = ['admin', 'editor'];

// This would throw a TypeError:
// $user->id = 'not an integer';

Nullable and Union Types

Sometimes a property can be null or multiple types. Use nullable types (e.g., ?string) or union types (e.g., int|string). Union types were introduced in PHP 8.0. They allow a property to accept multiple types, but be careful: too many union types can indicate a design flaw.

Example: A nullable email and a union type for a mixed value.

<?php

class Product {
    public ?string $description = null;
    public int|string $identifier;
}

$product = new Product();
$product->identifier = 123; // int
$product->identifier = 'SKU-456'; // also valid
// $product->identifier = 12.5; // TypeError: float not allowed

Readonly Properties: Immutability Made Easy

Readonly properties (PHP 8.1) can only be assigned once, typically in the constructor. After initialization, any attempt to modify them throws an Error. This is perfect for value objects, DTOs, and configuration objects. Readonly properties can be typed and can have default values. They cannot be unset.

Example: A readonly configuration class.

<?php

class AppConfig {
    public readonly string $appName;
    public readonly string $version;

    public function __construct(string $appName, string $version) {
        $this->appName = $appName;
        $this->version = $version;
    }
}

$config = new AppConfig('MyApp', '1.0.0');
echo $config->appName; // MyApp
// $config->appName = 'NewName'; // Error: Cannot modify readonly property

Property Hooks: Custom Get/Set Logic (PHP 8.4)

Property hooks, introduced in PHP 8.4, allow you to define custom get and set logic directly on a property, without writing separate getter and setter methods. This makes your code more concise and readable. The syntax uses get and set keywords inside the property declaration. The set hook receives the value to be assigned, and you can use $this->property to access the backing value.

Example: A property that always trims strings on set.

<?php

class User {
    public string $name {
        set => trim($value);
    }

    public string $email {
        set {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new InvalidArgumentException('Invalid email');
            }
            $this->email = $value;
        }
    }
}

$user = new User();
$user->name = '  Alice  ';
echo $user->name; // 'Alice'

$user->email = 'alice@example.com'; // OK
// $user->email = 'not-an-email'; // throws InvalidArgumentException

Combining Typed, Readonly, and Hooks

You can combine all three features for maximum safety and expressiveness. For example, a readonly property with a typed declaration and a get hook that computes a derived value. However, readonly properties cannot have set hooks because they are immutable. You can have a get hook on a readonly property.

Example: A readonly property that formats a date.

<?php

class Event {
    public readonly DateTimeImmutable $date;

    public string $formattedDate {
        get => $this->date->format('Y-m-d H:i:s');
    }

    public function __construct(DateTimeImmutable $date) {
        $this->date = $date;
    }
}

$event = new Event(new DateTimeImmutable('2025-01-15 10:30:00'));
echo $event->formattedDate; // 2025-01-15 10:30:00
// $event->date = new DateTimeImmutable(); // Error: readonly

Common Pitfalls and Best Practices

1. Uninitialized typed properties: Always initialize in constructor or with a default value.
2. Readonly properties in inheritance: A readonly property can be redeclared in a child class only if it's not already initialized. Use readonly classes to avoid issues.
3. Property hooks performance: Hooks add a small overhead. For hot paths, consider using methods.
4. Type widening: You cannot widen a property type in a subclass (e.g., from int to int|string).
5. Avoid side effects in get hooks: They should be idempotent and not modify state.

Example: A common mistake – forgetting to initialize a typed property.

<?php

class User {
    public string $name; // no default, not initialized in constructor
}

$user = new User();
echo $user->name; // Error: Typed property User::$name must not be accessed before initialization