Abstract Classes

Introduction

Some classes only really make sense as a blueprint for other classes. A generic "Shape" is a useful idea — every shape has an area — but it never makes sense to create a plain, unspecified `Shape` object on its own, since you would have no way to calculate its area. PHP lets you express exactly this idea with abstract classes.

An abstract class defines a shared foundation for a family of related classes, mixing behavior it already implements with behavior it deliberately leaves unfinished for each subclass to fill in.

The abstract Keyword

Adding `abstract` before `class` marks the class as incomplete on purpose. PHP will not let you create an object directly from an abstract class with `new` — you can only create objects from its concrete (non-abstract) subclasses.

<?php
abstract class Shape
{
    public function describe(): string
    {
        return "This shape has an area of " . $this->area();
    }

    abstract public function area(): float;
}

// $s = new Shape(); // Fatal error: Cannot instantiate abstract class Shape

Trying to run `new Shape()` produces a fatal error. PHP enforces that `Shape` is only ever used as a base for other classes, never as a standalone object — which makes sense, since `Shape` alone has no way to know how to calculate an area.

Abstract Methods

An abstract class can also declare abstract methods — methods with no body, marked with the `abstract` keyword. An abstract method only lists its name, parameters, and return type; every concrete subclass is required to provide a full implementation, or PHP raises an error.

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

class Triangle extends Shape
{
    // Forgot to implement area()
}

// Fatal error: Class Triangle contains 1 abstract method
// and must therefore be declared abstract or implement the remaining methods (area)

PHP will not let `Triangle` exist as written, because it inherited an abstract method it never fulfilled. Every concrete subclass of `Shape` must implement `area()` with matching visibility and a compatible signature.

Why Use Abstract Classes?

Abstract classes let you share real, working code across a family of related classes (like `describe()` above, which every shape inherits unchanged) while still forcing each subclass to supply the one piece of behavior that genuinely differs between them (like `area()`).

Worked Example: Shape, Circle, Square

Let's build out the `Shape` hierarchy fully, with two concrete subclasses that each calculate area differently.

<?php
abstract class Shape
{
    public function describe(): string
    {
        $name = static::class;
        return "{$name} has an area of " . round($this->area(), 2);
    }

    abstract public function area(): float;
}

class Circle extends Shape
{
    public function __construct(private float $radius) {}

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

class Square extends Shape
{
    public function __construct(private float $side) {}

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

$shapes = [new Circle(3), new Square(4)];

foreach ($shapes as $shape) {
    echo $shape->describe() . "\n";
}

Circle has an area of 28.27
Square has an area of 16

`describe()` is written once, in `Shape`, and works correctly for every subclass because it calls `$this->area()` — which resolves to whichever subclass's implementation is actually running. `Circle` and `Square` each only had to write the one method that genuinely differs between them: `area()`. This example also combines the previous two lessons — polymorphism (the shared `describe()`/`area()` calls) built on top of an abstract base class.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Abstract classes strike a balance between reuse and flexibility: they let a family of related classes share real, working code, while still guaranteeing that each subclass fills in the specific behavior that must vary. The Shape example showed both halves of that balance working together in a single, clean hierarchy.