PHP Inheritance: extends, parent:: and Overriding

In PHP a class inherits from another with extends: class Dog extends Animal gives Dog every public and protected property and method of Animal. The child can add new methods, override inherited ones by declaring a method with the same name, and call the original with parent::method().

<?php
class Animal
{
    public function __construct(protected string $name) {}

    public function speak(): string
    {
        return "{$this->name} makes a sound";
    }

    public function name(): string
    {
        return $this->name;
    }
}

class Dog extends Animal
{
    public function speak(): string
    {
        return "{$this->name} barks";
    }

    public function fetch(): string
    {
        return "{$this->name} brings the ball back";
    }
}

$generic = new Animal('Some animal');
$rex = new Dog('Rex');

echo $generic->speak(), "\n";
echo $rex->speak(), "\n";     // overridden
echo $rex->name(), "\n";      // inherited
echo $rex->fetch(), "\n";     // added

Dog has no constructor, so it uses Animal's, which is why new Dog('Rex') works. A child class can only extend one parent; PHP has no multiple inheritance of classes.

Call the parent method with parent::

Overriding replaces the parent's method completely. To extend it instead of replacing it, call parent::method() from the child and build on its result:

<?php
class Report
{
    public function header(): string
    {
        return "Sales report";
    }

    public function lines(): array
    {
        return ['Q1: 120', 'Q2: 98'];
    }
}

class DetailedReport extends Report
{
    public function header(): string
    {
        return parent::header() . " (detailed)";
    }

    public function lines(): array
    {
        $lines = parent::lines();
        $lines[] = 'Total: 218';
        return $lines;
    }
}

$r = new DetailedReport();
echo $r->header(), "\n";
echo implode("\n", $r->lines()), "\n";

The same works for constructors with parent::__construct(...), which the constructor page covers, including what happens when you forget it.

protected vs private in child classes

A protected member is hidden from outside code but visible to every class in the family. A private member is visible only in the class that declares it, so a child class cannot see it at all:

<?php
class BankAccount
{
    protected float $balance = 100;
    private string $pin = '1234';

    public function hasPin(): bool
    {
        return $this->pin !== '';
    }
}

class SavingsAccount extends BankAccount
{
    public function addInterest(float $rate): void
    {
        $this->balance *= 1 + $rate;   // protected: allowed
    }

    public function balance(): float
    {
        return $this->balance;
    }

    public function pinKnown(): bool
    {
        return isset($this->pin);      // private in the parent: not visible here
    }
}

$s = new SavingsAccount();
$s->addInterest(0.05);
echo $s->balance(), "\n";
var_dump($s->pinKnown(), $s->hasPin());

isset($this->pin) is false in the child because the child has no access to the parent's private $pin, while the parent's own method hasPin() still reads it. Use protected for what subclasses are meant to build on, and private for details you want to keep free to change.

Polymorphism and instanceof

Code written against the parent type works with every child. Each object runs its own version of an overridden method, so one loop handles all of them. instanceof checks whether an object is of a class or any of its children:

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

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

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

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

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

function totalArea(Shape ...$shapes): float
{
    return array_sum(array_map(fn (Shape $s) => $s->area(), $shapes));
}

$shapes = [new Rectangle(3, 4), new Circle(1), new Rectangle(2, 2)];
printf("Total area: %.2f\n", totalArea(...$shapes));

foreach ($shapes as $s) {
    echo get_class($s), ': ', $s instanceof Shape ? 'is a Shape' : 'not a Shape';
    echo $s instanceof Circle ? ', is a Circle' : '', "\n";
}
echo get_parent_class(new Circle(2)), "\n";

When the parent should never be used on its own (a plain Shape with area 0 makes little sense), make it an abstract class and declare area() abstract.

Overriding rules: signatures must stay compatible

An overriding method must accept at least what the parent accepted and return something the parent's callers can use. You can add an optional parameter, widen a parameter type, or narrow a return type; you cannot add a required parameter or make a public method private.

<?php
class Exporter
{
    public function export(array $rows): string
    {
        return implode(';', array_map(fn ($r) => implode(',', $r), $rows));
    }
}

class CsvExporter extends Exporter
{
    // Adds an optional parameter: compatible
    public function export(array $rows, string $sep = ','): string
    {
        return implode("\n", array_map(fn ($r) => implode($sep, $r), $rows));
    }
}

$rows = [['id', 'name'], [1, 'Ada'], [2, 'Linus']];
echo (new Exporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows), "\n\n";
echo (new CsvExporter())->export($rows, "\t"), "\n";

Change string $sep = ',' to a required string $sep and PHP refuses to compile the class with a fatal error ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

final classes and methods

final stops inheritance at that point. A final method cannot be overridden, and a final class cannot be extended. Both are checked when the file is compiled, so the script does not start at all:

<?php
class Payment
{
    final public function charge(int $cents): string
    {
        return "charged $cents";
    }
}

class FreePayment extends Payment
{
    public function charge(int $cents): string
    {
        return 'free';
    }
}

PHP Fatal error:  Cannot override final method Payment::charge() in /home/index.php on line 12

For a final class the message is Class B cannot extend final class A. Mark a method final when the parent relies on it behaving exactly one way, for example a method that checks permissions before doing anything else.

The private method trap

A private method is not inherited, so a child method with the same name does not override it. Code in the parent keeps calling its own private version, which surprises people who expect the child's method to run:

<?php
class Greeter
{
    public function greet(): string
    {
        return $this->word() . ', world';
    }

    private function word(): string
    {
        return 'Hello';
    }
}

class FrenchGreeter extends Greeter
{
    public function word(): string
    {
        return 'Bonjour';
    }
}

echo (new FrenchGreeter())->greet(), "\n";
echo (new FrenchGreeter())->word(), "\n";

greet() still prints Hello: the parent's $this->word() resolves to the parent's private method. Change private to protected in Greeter and run it again; now the child's method is a real override and greet() says Bonjour.