PHP Abstract Class: Abstract Methods and When to Use

A PHP abstract class is declared with abstract class Name and cannot be created with new. It is a base for other classes: it can have properties, a constructor and finished methods, plus abstract methods with no body, which every child class must implement.

<?php
abstract class Shape
{
    public function __construct(protected string $label) {}

    abstract public function area(): float;

    public function describe(): string
    {
        return sprintf('%s: %.2f', $this->label, $this->area());
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h)
    {
        parent::__construct('Rectangle');
    }

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r)
    {
        parent::__construct('Circle');
    }

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

foreach ([new Rectangle(3, 4), new Circle(1.5)] as $shape) {
    echo $shape->describe(), "\n";
}

describe() is written once in Shape and calls area(), which each child supplies. The abstract class guarantees that the method exists, so describe() can rely on it.

You cannot create an abstract class with new

An abstract class is incomplete on purpose: Shape::area() has no body, so a plain Shape object would have nothing to run. PHP refuses to create one and throws an Error:

<?php
abstract class Shape
{
    abstract public function area(): float;
}

try {
    $s = new Shape();
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

$r = new ReflectionClass('Shape');
var_dump($r->isAbstract());

Abstract methods: the rules

An abstract method has a signature and a semicolon instead of a body. Each child must implement it with a compatible signature and the same or wider visibility: an abstract protected method may become protected or public in the child, never private. A class with even one abstract method must itself be declared abstract.

<?php
abstract class Notification
{
    public function __construct(protected string $recipient) {}

    abstract protected function channel(): string;

    abstract protected function format(string $text): string;

    public function send(string $text): string
    {
        return "[{$this->channel()}] to {$this->recipient}: " . $this->format($text);
    }
}

class SmsNotification extends Notification
{
    protected function channel(): string
    {
        return 'SMS';
    }

    protected function format(string $text): string
    {
        return rtrim(mb_substr($text, 0, 20)) . (mb_strlen($text) > 20 ? '...' : '');
    }
}

class EmailNotification extends Notification
{
    public function channel(): string   // protected widened to public: allowed
    {
        return 'Email';
    }

    protected function format(string $text): string
    {
        return "Hello,\n\n$text\n\nRegards";
    }
}

echo (new SmsNotification('+3912345'))->send('Your parcel arrives tomorrow between 9 and 12'), "\n\n";
echo (new EmailNotification('ada@example.com'))->send('Your parcel arrives tomorrow.'), "\n";

A child that skips an abstract method stops the script before any of it runs, unless the child is also declared abstract and leaves the method to its own children:

PHP Fatal error:  Class Square contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Shape::area) in /home/index.php on line 3

The template method pattern

The most common reason to write an abstract class: a fixed sequence of steps where a few steps differ. The base class owns the sequence in a final method, and children fill in the steps. Here the same report runs as plain text and as an HTML table:

<?php
abstract class Report
{
    public function __construct(protected array $rows) {}

    final public function render(): string
    {
        $out = $this->open();
        foreach ($this->rows as $row) {
            $out .= $this->row($row);
        }
        return $out . $this->close();
    }

    abstract protected function row(array $row): string;

    protected function open(): string { return ''; }
    protected function close(): string { return ''; }
}

class TextReport extends Report
{
    protected function row(array $row): string
    {
        return str_pad($row[0], 10) . $row[1] . "\n";
    }
}

class HtmlReport extends Report
{
    protected function open(): string { return "<table border=\"1\">\n"; }
    protected function close(): string { return "</table>\n"; }

    protected function row(array $row): string
    {
        return '<tr><td>' . htmlspecialchars($row[0]) . '</td><td>' . $row[1] . "</td></tr>\n";
    }
}

$rows = [['Apples', 12], ['Pears', 7], ['Plums', 30]];
echo (new HtmlReport($rows))->render();
echo '<pre>' . (new TextReport($rows))->render() . '</pre>';

Run it and the Page tab shows the HTML table above the plain text version. open() and close() have default bodies, so only HtmlReport bothers to override them; row() is abstract because there is no sensible default. Making render() final keeps a child from changing the order of the steps.

An abstract class can implement an interface

An abstract class may declare implements and leave some of the interface's methods for its children. This is the standard way to pair an interface (the type) with a base class (the shared code):

<?php
interface Cache
{
    public function get(string $key): mixed;
    public function set(string $key, mixed $value): void;
    public function has(string $key): bool;
}

abstract class BaseCache implements Cache
{
    // has() is written once, in terms of get()
    public function has(string $key): bool
    {
        return $this->get($key) !== null;
    }
}

class ArrayCache extends BaseCache
{
    private array $items = [];

    public function get(string $key): mixed
    {
        return $this->items[$key] ?? null;
    }

    public function set(string $key, mixed $value): void
    {
        $this->items[$key] = $value;
    }
}

$cache = new ArrayCache();
$cache->set('user:1', 'Ada');
var_dump($cache->has('user:1'), $cache->has('user:2'));
var_dump($cache instanceof Cache);

Code type-hints the interface Cache, so a class that cannot extend BaseCache (because it already extends something else) can still implement Cache directly.

When to use an abstract class, and when not to

Reach for an abstract class when the classes in a family share real code: properties, a constructor, methods that are the same for all of them. If the base would contain nothing but abstract methods, it is an interface in disguise, and an interface is the better choice because a class can implement many interfaces but extend only one class. If you only want to share a few helper methods between unrelated classes, use a trait instead of forcing them under one parent.

A quick test before writing abstract class: would every child really be a kind of the base (Circle is a Shape)? If the honest answer is "it can do this" rather than "it is one of these", write an interface.