Herencia e interfaces

La herencia permite que una clase se construya sobre otra; las interfaces permiten que clases no relacionadas prometan admitir el mismo conjunto de métodos.

Extender una clase

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

    public function makeSound(): string {
        return "...";
    }
}

class Dog extends Animal {
    public function makeSound(): string {
        return "{$this->name} says Woof!";
    }
}

$dog = new Dog("Rex");
echo $dog->makeSound(); // "Rex says Woof!"

extends convierte a Dog en una subclase de Animal, heredando automáticamente su constructor y propiedades. makeSound() está sobrescrito — la versión de Dog reemplaza a la de Animal para cualquier instancia de Dog, un mecanismo llamado polimorfismo: el código que simplemente llama a $animal->makeSound() obtiene el comportamiento correcto sin importar de qué subclase se trate realmente $animal.

Llamar a la implementación de la clase padre

<?php
class Employee {
    public function __construct(protected string $name, protected float $baseSalary) {}

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

class Manager extends Employee {
    public function __construct(string $name, float $baseSalary, private float $bonus) {
        parent::__construct($name, $baseSalary);
    }

    public function getSalary(): float {
        return parent::getSalary() + $this->bonus;
    }
}

parent:: llama explícitamente a la versión de la clase padre de un método (o a su constructor) — útil cuando una subclase quiere extender el comportamiento en lugar de reemplazarlo por completo, como hace aquí Manager::getSalary() sumando una bonificación al cálculo heredado.

Clases abstractas

<?php
abstract class Shape {
    abstract public function area(): float;

    public function describe(): string {
        return "Area: " . $this->area();
    }
}

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

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

Una clase abstract no se puede instanciar directamente (new Shape() es un error) y puede declarar métodos abstract sin cuerpo — toda subclase concreta está obligada a implementarlos. describe() es un método normal y heredado que funciona para cualquier subclase, ya que solo depende de que exista area(), no de cómo cada forma calcula su área.

Interfaces: un contrato sin implementación

<?php
interface Payable {
    public function calculatePayment(): float;
}

class Freelancer implements Payable {
    public function __construct(private float $hourlyRate, private int $hours) {}

    public function calculatePayment(): float {
        return $this->hourlyRate * $this->hours;
    }
}

function processPayment(Payable $entity): void {
    echo "Paying: " . $entity->calculatePayment();
}

Una interface declara firmas de métodos sin ninguna implementación — una clase la implements (implementa) como promesa de que proporciona esos métodos. A diferencia de extends (herencia única — una clase solo puede extender un padre), una clase puede implements varias interfaces a la vez, que es como PHP logra algo similar a la herencia múltiple para contratos de comportamiento sin la complejidad de una verdadera herencia múltiple de clases.