Magic Methods

Introduction

You have already used two special methods without necessarily thinking of them that way: `__construct()`, which PHP calls automatically when an object is created, and `__destruct()`, which PHP calls automatically when an object is destroyed. These are examples of a broader category called magic methods.

Magic methods are special methods, always prefixed with a double underscore, that PHP invokes automatically in specific situations — converting an object to a string, accessing an undefined property, or calling an undefined method. They let your objects respond intelligently to situations you cannot fully predict in advance.

What Are Magic Methods?

A magic method is a method with a reserved name, always beginning with two underscores, that PHP calls automatically at a specific moment — not because your code explicitly calls it, but because PHP's engine triggers it in response to something happening to the object.

Recap: __construct and __destruct

You met these two in an earlier lesson. `__construct()` runs automatically right after an object is created, typically to initialize its properties. `__destruct()` runs automatically right before an object is removed from memory, often used for cleanup like closing a file handle.

<?php
class Connection
{
    public function __construct(private string $name)
    {
        echo "Opening connection: {$this->name}\n";
    }

    public function __destruct()
    {
        echo "Closing connection: {$this->name}\n";
    }
}

$conn = new Connection("Database");
echo "Using connection...\n";

Opening connection: Database
Using connection...
Closing connection: Database

__toString

By default, PHP does not know how to display an object as text. The `__toString()` magic method lets you define exactly what should happen whenever an object is used somewhere a string is expected, such as inside `echo` or string concatenation.

<?php
class Product
{
    public function __construct(
        private string $name,
        private float $price
    ) {}

    public function __toString(): string
    {
        return "{$this->name} - $" . number_format($this->price, 2);
    }
}

$product = new Product("Wireless Mouse", 24.5);
echo $product;

Wireless Mouse - $24.50

Without `__toString()`, trying to `echo $product` directly would cause a fatal error, since PHP would not know how to represent the object as text.

__get and __set

`__get($name)` is called automatically when code tries to read a property that is either undefined or inaccessible (like a private property from outside the class). `__set($name, $value)` is called automatically when code tries to write to such a property. Together, they let you intercept and control property access.

<?php
class Settings
{
    private array $data = [];

    public function __get(string $name)
    {
        return $this->data[$name] ?? null;
    }

    public function __set(string $name, $value): void
    {
        echo "Setting '$name' to '$value'\n";
        $this->data[$name] = $value;
    }
}

$settings = new Settings();
$settings->theme = "dark";
echo $settings->theme;

Setting 'theme' to 'dark'
dark

__call

`__call($name, $arguments)` is called automatically whenever code tries to call a method that does not exist (or is not accessible) on an object. It receives the method name that was attempted and an array of the arguments passed.

<?php
class ApiClient
{
    public function __call(string $name, array $arguments)
    {
        $endpoint = strtolower($name);
        return "Calling endpoint '/$endpoint' with " . count($arguments) . " argument(s)";
    }
}

$client = new ApiClient();
echo $client->getUsers(1, 20);

Calling endpoint '/getusers' with 2 argument(s)

This is exactly the technique many frameworks use to build flexible, dynamic APIs — methods that were never explicitly written can still be "called" and handled generically.

Worked Example: Money Class

Here is a small `Money` class that uses `__toString()` to make displaying money values natural and readable anywhere a string is expected.

<?php
class Money
{
    public function __construct(
        private float $amount,
        private string $currency = "USD"
    ) {}

    public function add(Money $other): Money
    {
        return new Money($this->amount + $other->amount, $this->currency);
    }

    public function __toString(): string
    {
        return number_format($this->amount, 2) . " {$this->currency}";
    }
}

$price = new Money(19.99);
$tax = new Money(1.60);
$total = $price->add($tax);

echo "Price: $price\n";
echo "Tax: $tax\n";
echo "Total: $total";

Price: 19.99 USD
Tax: 1.60 USD
Total: 21.59 USD

Notice `$price`, `$tax`, and `$total` are all `Money` objects, but embedding them directly into strings just works — `__toString()` handles the conversion automatically.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Magic methods give your classes hooks into moments PHP normally handles silently — object creation, string conversion, undefined property access, and undefined method calls. Used well, they make objects feel natural to work with; used carelessly, they can hide what your code is actually doing.

In this lesson, you reviewed __construct and __destruct, and learned __toString, __get, __set, and __call, finishing with a Money class example. Next, you will learn about static properties and methods, which belong to the class itself rather than to any individual instance.