Inheritance

Introduction

Imagine you already have a `Vehicle` class with common properties like speed and fuel, and now you need a `Car` and a `Motorcycle` that share all of that but each add their own extra behavior. Copy-pasting the `Vehicle` code into both would work, but any future fix would need to be repeated in three places. Inheritance solves this by letting one class reuse and extend another.

This lesson covers how to create a child class with `extends`, how to override inherited methods, how to still call the parent's version of a method with `parent::`, and an important limit: PHP only allows a class to extend one parent.

Extending a Class

A child class (also called a subclass) is created with the `extends` keyword. It automatically gains every public and protected property and method from its parent class, and can add new ones of its own.

<?php
class Animal
{
    protected string $name;

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

    public function eat(): void
    {
        echo "{$this->name} is eating.\n";
    }
}

class Dog extends Animal
{
    public function bark(): void
    {
        echo "{$this->name} says Woof!\n";
    }
}

$rex = new Dog("Rex");
$rex->eat();  // inherited from Animal
$rex->bark(); // defined in Dog

Rex is eating.
Rex says Woof!

`Dog` never redefines `eat()` or the constructor, yet `$rex` has full access to both because `Dog extends Animal`. The `protected` property `$name` is also inherited and usable inside `Dog`, since protected members are visible to subclasses.

Overriding Methods

A subclass can redefine a method it inherits, replacing the parent's implementation with its own. This is called method overriding, and it is one of the most powerful features inheritance provides.

<?php
class Animal
{
    protected string $name;

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

    public function makeSound(): void
    {
        echo "{$this->name} makes a generic animal sound.\n";
    }
}

class Cat extends Animal
{
    public function makeSound(): void
    {
        echo "{$this->name} says Meow!\n";
    }
}

$generic = new Animal("Creature");
$cat = new Cat("Whiskers");

$generic->makeSound();
$cat->makeSound();

Creature makes a generic animal sound.
Whiskers says Meow!

`Cat` provides its own `makeSound()` with the exact same name and signature as `Animal`'s, so calling it on a `Cat` object runs the overridden version instead of the parent's.

Calling the Parent with parent::

Sometimes you want to override a method but still run the parent's original logic first, adding to it rather than fully replacing it. The `parent::` keyword lets a subclass explicitly call the parent class's version of a method or constructor.

<?php
class Employee
{
    protected string $name;
    protected float $baseSalary;

    public function __construct(string $name, float $baseSalary)
    {
        $this->name = $name;
        $this->baseSalary = $baseSalary;
    }

    public function describe(): string
    {
        return "{$this->name} earns \${$this->baseSalary}";
    }
}

class Manager extends Employee
{
    private float $bonus;

    public function __construct(string $name, float $baseSalary, float $bonus)
    {
        parent::__construct($name, $baseSalary); // reuse the parent constructor
        $this->bonus = $bonus;
    }

    public function describe(): string
    {
        $base = parent::describe(); // reuse the parent method, then add to it
        return $base . " plus a \${$this->bonus} bonus";
    }
}

$m = new Manager("Jordan", 60000, 5000);
echo $m->describe() . "\n";

Jordan earns $60000 plus a $5000 bonus

`Manager::__construct()` calls `parent::__construct()` to handle the shared setup, then adds its own. `Manager::describe()` does the same with the string it builds, extending the parent's output instead of duplicating it.

Single Inheritance in PHP

PHP only supports single inheritance: a class can extend exactly one parent class, never more than one. Writing `class Foo extends Bar, Baz` is a syntax error — PHP simply does not allow it.

This restriction keeps class hierarchies simple and predictable: given any class, there is exactly one chain of parents to trace, with no ambiguity about which parent a method or property came from.

Why Inheritance Models "Is-A"

Inheritance should be used when the relationship between two classes is genuinely "is-a": a `Dog` is an `Animal`, a `Manager` is an `Employee`, a `Car` is a `Vehicle`. If that sentence does not sound natural, inheritance is probably the wrong tool.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Inheritance lets you build a hierarchy of classes that share common behavior while each adding or overriding their own. Using extends, method overriding, and parent::, you can reuse code confidently, and PHP's single-inheritance rule keeps that hierarchy simple to reason about.