Chapter 07 · OOP Foundations

Inheritance

Sometimes two classes are 90% the same. Students and lecturers both have names, emails and ID numbers — only some details differ. Must we copy-paste? Never! Inheritance lets a new class receive everything from an existing one, then add its own extras.

The extends keyword

<?php
// The parent (also called "base class" or "super class")
class Person {
    public function __construct(
        public string $name,
        public string $email
    ) {}

    public function introduce(): string {
        return "Hello, I am $this->name.";
    }
}

// The children — each one "extends" (inherits from) Person
class Student extends Person {
    public string $program = "Undeclared";

    public function study(): string {
        return "$this->name is studying $this->program.";
    }
}

class Lecturer extends Person {
    public function teach(string $course): string {
        return "$this->name is teaching $course.";
    }
}

$s = new Student("Chanda", "[email protected]");
$s->program = "BSc Computing";

echo $s->introduce();   // inherited from Person — we never wrote it in Student!
echo "<br>";
echo $s->study();       // Student's own new skill

$l = new Lecturer("Mr. Mwale", "[email protected]");
echo "<br>" . $l->introduce();
echo "<br>" . $l->teach("PHP OOP");

Notice: Student never declared $name, $email, __construct or introduce() — yet it has them all. They flowed down from Person. We wrote the shared code once.

Overriding — the child does it differently

A child can replace an inherited method by simply declaring a method with the same name. This is our first taste of polymorphism (same instruction, different behaviour):

class Person {
    public function __construct(public string $name) {}

    public function introduce(): string {
        return "Hello, I am $this->name.";
    }
}

class Lecturer extends Person {
    // Same method name = override. The child's version wins.
    public function introduce(): string {
        return "Good morning class, I am $this->name, your lecturer.";
    }
}

$people = [new Person("Chanda"), new Lecturer("Mr. Mwale")];

foreach ($people as $p) {
    echo $p->introduce() . "<br>";   // same call, different results!
}

That loop is the magic moment: we call the same method on every object and each object answers in its own way. The loop doesn't need to know or care who is who.

parent:: — extend, don't replace

Often the child doesn't want to throw away the parent's version — it wants to add to it. The keyword parent:: calls the parent's version:

class Student extends Person {
    public function __construct(string $name, public string $studentNumber) {
        parent::__construct($name);   // let Person handle the name first
        // then do my own extra setup
    }

    public function introduce(): string {
        return parent::introduce() . " My student number is $this->studentNumber.";
    }
}

$s = new Student("Chanda", "LGU2026-001");
echo $s->introduce();

Where protected finally makes sense

Remember the middle visibility from last chapter? private is so strict that even children are locked out. protected is the family key:

class Person {
    protected string $idNumber = "";   // family only: me + my children

    public function __construct(string $idNumber) {
        $this->idNumber = $idNumber;
    }
}

class Student extends Person {
    public function idCard(): string {
        // ✓ allowed: protected is visible to children
        return "STUDENT CARD — ID: $this->idNumber";
    }
}

$s = new Student("123456/78/9");
echo $s->idCard();       // works
echo $s->idNumber;       // 💥 error: outsiders still locked out

Stopping inheritance with final

Occasionally you want to say "this may not be overridden / extended". The final keyword does that — on a method (final public function pay()...) or a whole class (final class PaymentGateway { ... }). You'll mostly read it in other people's code; just know it means "hands off".

<?php
class Vehicle {
    public function __construct(public string $brand) {}

    public function start(): string {
        return "The $this->brand engine starts. Vroom.";
    }
}

class ElectricCar extends Vehicle {
    public function start(): string {
        return "The $this->brand powers on. ...silence.";
    }
}

$v = new Vehicle("Toyota");
$e = new ElectricCar("Tesla");
echo $v->start() . "<br>";
echo $e->start();