PHP soporta herencia OOP y abstracción a través de tres mecanismos relacionados: herencia de clases (extends), clases abstractas (clases base parciales), e interfaces (contratos). Cada uno sirve un propósito de diseño diferente.
{
{}
{ ; }
}
{
{ ; }
{
::() . ;
}
}
Una subclase extends una clase padre, heredando y opcionalmente sobrescribiendo sus miembros. parent:: llama al método padre sobrescrito. PHP soporta herencia simple (un solo padre).
abstract class Shape {
abstract public function area(): float; // abstract — subclasses MUST implement
public function describe(): string { // concrete — shared implementation
return "Area: " . $this->area();
}
}
class Circle extends Shape {
public function __construct(private float $r) {}
public function area(): float { return 3.14159 * $this->r ** 2; } // must implement
}
// new Shape(); // ❌ error — abstract classes can't be instantiated
Una clase abstracta mezcla métodos abstractos (que las subclases deben implementar) con código compartido concreto — una base que no se puede instanciar directamente.
interface Drawable {
public function draw(): void; // only signatures — no implementation
}
interface Serializable {
public function serialize(): string;
}
class Widget implements Drawable, Serializable { // implement MULTIPLE interfaces
public function draw(): void { /* ... */ }
public function serialize(): string { return "..."; }
}
Una interface define un contrato (firmas de métodos, sin implementación). Una clase puede implement muchas interfaces — la forma que tiene PHP de evitar la herencia simple para compartir capacidades.
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
La herencia, las clases abstractas y las interfaces son herramientas OOP fundamentales, y entender las distinciones es importante para diseñar aplicaciones PHP bien estructuradas (y para trabajar con frameworks, que se apoyan fuertemente en estos). La herencia (extends) proporciona reutilización de código mediante relaciones "es-un", pero PHP permite solo herencia simple. Las clases abstractas proporcionan una base compartida con código implementado y métodos que las subclases deben definir — bueno para clases estrechamente relacionadas que comparten lógica. Las interfaces definen contratos/capacidades, y crucialmente una clase puede implementar muchas de ellas — haciendo que las interfaces sean clave para diseños flexibles y desacoplados, y la respuesta de PHP a la limitación de herencia simple.
Saber cuándo usar cada una (herencia para reutilización es-un, clases abstractas para implementación parcial compartida, interfaces para contratos/capacidades), y el principio de programar hacia interfaces (depender de abstracciones para código testeable, flexible y compatible con frameworks), es conocimiento importante para el diseño orientado a objetos en PHP.
Estos mecanismos subyacen en cómo los frameworks como Laravel y Symfony estructuran su código (interfaces y clases base abstractas por todas partes), lo que los hace esenciales tanto para diseñar bien tu propio código como para entender los frameworks en los que construyes.