Chapter 08 · Going Deeper

Abstract Classes & Interfaces

Sometimes a parent class is only an idea, never a real thing. You can meet a Student and a Lecturer — but have you ever met a plain "Person-in-general" walking down the street? This chapter teaches PHP's two tools for describing ideas and contracts: abstract classes and interfaces.

Abstract classes — templates that can't be built

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

    // Abstract method: NO body. Every child MUST write its own version.
    abstract public function area(): float;

    // Normal method: shared by all children, written once.
    public function describe(): string {
        return "A $this->color shape with area " . $this->area();
    }
}

class Circle extends Shape {
    public function __construct(string $color, private float $radius) {
        parent::__construct($color);
    }
    public function area(): float {
        return round(3.14159 * $this->radius ** 2, 2);
    }
}

class Rectangle extends Shape {
    public function __construct(string $color, private float $w, private float $h) {
        parent::__construct($color);
    }
    public function area(): float {
        return $this->w * $this->h;
    }
}

$shapes = [new Circle("red", 5), new Rectangle("blue", 4, 6)];
foreach ($shapes as $shape) {
    echo $shape->describe() . "<br>";
}

$s = new Shape("green");   // 💥 Error: Cannot instantiate abstract class

Three rules to memorise:

• abstract class — cannot be created with new. It exists only to be extended.
• An abstract method has no body — just a signature ending in ;. It is a promise: "every child will implement this."
• If a child forgets to implement an abstract method, PHP refuses to run. The contract is enforced.

Look at describe() — it calls $this->area() even though Shape itself has no idea how to compute an area! It trusts that whichever child is running will supply one. Shared logic on top, specific logic below: that's the abstract-class superpower.

Interfaces — pure contracts

interface Payable {
    public function pay(float $amount): string;   // no body — only the promise
}

interface Printable {
    public function printOut(): string;
}

// A class "implements" an interface — and may implement several at once
class TuitionInvoice implements Payable, Printable {
    public function __construct(public string $student, public float $total) {}

    public function pay(float $amount): string {
        $this->total -= $amount;
        return "Paid K$amount. Remaining: K$this->total";
    }
    public function printOut(): string {
        return "INVOICE — $this->student — K$this->total";
    }
}

class LibraryFine implements Payable {
    public function __construct(public float $total) {}

    public function pay(float $amount): string {
        $this->total -= $amount;
        return "Fine reduced by K$amount.";
    }
}

// The magic: this function accepts ANYTHING that fits the Payable socket
function processPayment(Payable $bill, float $amount): void {
    echo $bill->pay($amount) . "<br>";
}

processPayment(new TuitionInvoice("Chanda", 5000), 1500);
processPayment(new LibraryFine(80), 50);

The function processPayment() doesn't know or care what kind of bill it received. It only knows: "this thing promised it can pay()". Invoices and fines aren't even related by inheritance — they just fit the same socket. That is polymorphism at its purest.

Abstract class vs interface — which one when?

<?php
interface Notifiable {
    public function send(string $message): string;
}

class EmailNotifier implements Notifiable {
    public function send(string $message): string {
        return "EMAIL: $message";
    }
}

class SmsNotifier implements Notifiable {
    public function send(string $message): string {
        return "SMS: $message";
    }
}

function alertStudent(Notifiable $channel): void {
    echo $channel->send("Results are out!") . "<br>";
}

alertStudent(new EmailNotifier());
alertStudent(new SmsNotifier());