Herança em PHP: extends, parent:: e sobrescrita

No PHP, uma classe herda de outra com extends: class Dog extends Animal dá a Dog todas as propriedades e métodos public e protected de Animal. A filha pode adicionar novos métodos, sobrescrever os herdados declarando um método com o mesmo nome e chamar o original com 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 não tem construtor, então usa o de Animal, e é por isso que new Dog('Rex') funciona. Uma classe filha só pode estender uma classe pai; o PHP não tem herança múltipla de classes.

Chamar o método da classe pai com parent::

Sobrescrever substitui o método da classe pai por completo. Para estendê-lo em vez de substituí-lo, chame parent::method() na filha e trabalhe em cima do resultado:

<?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";

O mesmo vale para construtores com parent::__construct(...), que a página sobre construtores explica, incluindo o que acontece quando você o esquece.

protected ou private em classes filhas

Um membro protected fica escondido do código de fora, mas visível para todas as classes da família. Um membro private só é visível na classe que o declara, então uma classe filha não o enxerga:

<?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) é falso na filha porque ela não tem acesso ao $pin privado da classe pai, enquanto o próprio método hasPin() da classe pai ainda o lê. Use protected para o que as subclasses devem usar como base, e private para detalhes que você quer poder mudar livremente.

Polimorfismo e instanceof

Código escrito para o tipo da classe pai funciona com todas as filhas. Cada objeto executa a própria versão de um método sobrescrito, então um único loop trata todos eles. instanceof verifica se um objeto é de uma classe ou de qualquer uma das filhas dela:

<?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";

Quando a classe pai nunca deve ser usada sozinha (um Shape simples com área 0 faz pouco sentido), torne-a uma classe abstrata e declare area() como abstrato.

Regras de sobrescrita: as assinaturas precisam continuar compatíveis

Um método que sobrescreve precisa aceitar pelo menos o que o da classe pai aceitava e retornar algo que quem chama a classe pai consiga usar. Você pode adicionar um parâmetro opcional, ampliar o tipo de um parâmetro ou restringir o tipo de retorno; não pode adicionar um parâmetro obrigatório nem tornar privado um método público.

<?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";

Troque string $sep = ',' por um string $sep obrigatório e o PHP se recusa a compilar a classe com um erro fatal ("Declaration of CsvExporter::export(array $rows, string$sep): string must be compatible with Exporter::export(array $rows): string").

Classes e métodos final

final interrompe a herança naquele ponto. Um método final não pode ser sobrescrito, e uma final class não pode ser estendida. As duas regras são verificadas quando o arquivo é compilado, então o script nem começa:

<?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

Para uma classe final, a mensagem é Class B cannot extend final class A. Marque um método como final quando a classe pai depende de ele se comportar de um único jeito, por exemplo um método que verifica permissões antes de fazer qualquer outra coisa.

A armadilha dos métodos privados

Um método privado não é herdado, então um método da filha com o mesmo nome não o sobrescreve. O código da classe pai continua chamando a própria versão privada, o que surpreende quem espera que o método da filha rode:

<?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() ainda imprime Hello: o $this->word() da classe pai aponta para o método privado da classe pai. Troque private por protected em Greeter e rode de novo; agora o método da filha é uma sobrescrita de verdade e greet() diz Bonjour.