extends

La palabra clave extends en PHP

extends es la forma en que una clase declara herencia en PHP: una clase hija (o subclase) construida con extends adquiere automáticamente las propiedades y métodos no privados de su clase padre (o superclase). En lugar de copiar el código compartido en cada clase relacionada, se escribe una vez en la clase padre y se deja que las subclases lo especialicen.

Esta página cubre la sintaxis, cómo llamar al código del padre con parent::, cómo funciona la sobreescritura de métodos, las reglas de modificadores de acceso que determinan qué hereda una clase hija, y los errores comunes que suelen cometerse. PHP soporta herencia simple únicamente — una clase puede hacer extends de exactamente un padre (usa interfaces cuando necesites que un tipo desempeñe varios roles).

Sintaxis

class ChildClass extends ParentClass {
  // additional or overriding members
}

La clase hija puede hacer tres cosas:

1. Heredar miembros del padre sin cambios.
2. Agregar nuevas propiedades y métodos propios.
3. Sobreescribir un método heredado redeclarándolo con el mismo nombre.

Un primer ejemplo

<?php

class Fruit {
  public $name;
  public $color;

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

  public function getInfo() {
    echo "This fruit is a {$this->name} and it is {$this->color}.";
  }
}

// Apple inherits everything from Fruit and overrides getInfo().
class Apple extends Fruit {
  public function getInfo() {
    echo "This fruit is an {$this->name} and it is {$this->color}.";
  }
}

$apple = new Apple("apple", "red");
$apple->getInfo();
// Output: This fruit is an apple and it is red.

Apple nunca declara $name, $color ni un constructor — los hereda de Fruit. Solo redefine getInfo(), lo que sobreescribe la versión del padre.

Llamar al padre con parent::

Una clase hija frecuentemente quiere extender el comportamiento del padre en lugar de reemplazarlo. Cuando una clase hija define su propio constructor, PHP no llama al constructor del padre automáticamente — debes llamarlo explícitamente con parent::__construct(). La misma sintaxis parent:: funciona para cualquier método sobreescrito.

<?php

class Car {
  public $model;
  public $year;

  public function __construct($model, $year) {
    $this->model = $model;
    $this->year = $year;
  }

  public function getInfo() {
    echo "This car is a {$this->model} from {$this->year}.";
  }
}

class Toyota extends Car {
  public function __construct($year) {
    // Fill in the model, defer the rest to the parent.
    parent::__construct("Toyota", $year);
  }

  public function getInfo() {
    parent::getInfo();            // reuse the parent's output...
    echo " (built by Toyota)";    // ...then add to it.
  }
}

$toyota = new Toyota(2021);
$toyota->getInfo();
// Output: This car is a Toyota from 2021. (built by Toyota)

Si Toyota no tuviera constructor, heredaría el constructor de Car y se crearía con new Toyota("Corolla", 2021).

Qué puede — y qué no puede — heredar una clase hija

Los modificadores de acceso determinan la visibilidad a través del límite de herencia:

• Los miembros public se heredan y son utilizables en cualquier parte.
• Los miembros protected se heredan y son accesibles dentro de la clase hija, pero no desde fuera de la clase.
• Los miembros private no son accesibles en la clase hija. Siguen existiendo en el objeto, pero la hija no puede verlos por nombre.

<?php

class Account {
  public $owner = "Ann";
  protected $balance = 100;   // visible to children
  private $pin = "1234";      // hidden from children

  public function reveal() {
    return "$this->owner, balance $this->balance, pin $this->pin";
  }
}

class SavingsAccount extends Account {
  public function summary() {
    // $this->balance works (protected); $this->pin would be null/undefined.
    return "{$this->owner} has {$this->balance}";
  }
}

$s = new SavingsAccount();
echo $s->summary();
// Output: Ann has 100

Consulta los modificadores de acceso en PHP para conocer las reglas completas de public / protected / private.

Sellar una clase o método con final

Usa la palabra clave final para impedir extensiones adicionales. Una final class no puede ser padre; un método final no puede ser sobreescrito por una subclase. Esto es útil cuando sobreescribir rompería una invariante de la que depende tu clase.

class PaymentGateway {
  final public function charge() { /* must not be altered */ }
}

Errores comunes

• Olvidar parent::__construct(). Definir un constructor en la clase hija oculta el del padre. Si olvidas llamarlo, las propiedades del padre quedan sin inicializar.
• Herencia simple. class A extends B, C es un error de sintaxis. Compone comportamiento con interfaces o traits en su lugar.
• Los miembros privados no se comparten. Una propiedad private del padre es invisible para la clase hija; hazla protected si las subclases la necesitan.
• Las firmas de los métodos sobreescritos deben mantenerse compatibles. Un método sobreescrito debe aceptar los mismos argumentos (o más amplios), de lo contrario PHP emite una advertencia.

Temas relacionados

• Herencia en PHP — el concepto más amplio que implementa extends.
• Clases y objetos en PHP — los bloques de construcción.
• Clases abstractas — padres que deben ser extendidos.
• Interfaces — contratos para clases no relacionadas.

Práctica