La palabra clave parent::

Parte de la sección Programación Orientada a Objetos del Journey de PHP de Coddy — lección 22 de 91.

Cuando una clase hija hereda de una clase padre, a veces es necesario acceder directamente a los métodos o propiedades del padre. La palabra clave parent:: le permite llamar a la implementación de la clase padre desde la clase hija.

Esto es especialmente útil en los constructores cuando el hijo necesita inicializar las propiedades del padre mientras también configura las suyas propias:

<?php
class Animal {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    public $breed;
    
    public function __construct($name, $breed) {
        parent::__construct($name);
        $this->breed = $breed;
    }
    
    public function describe() {
        return "$this->name is a $this->breed";
    }
}

$dog = new Dog("Max", "Labrador");
echo $dog->describe();

Salida:

Max is a Labrador

Al llamar a parent::__construct($name), la clase hija reutiliza la lógica de inicialización del padre en lugar de duplicarla. Sin esta llamada, la propiedad $name nunca se establecería.

Puedes usar parent:: para llamar a cualquier método padre, no solo a los constructores. Esto se vuelve particularmente importante cuando quieres extender el comportamiento de un método en lugar de reemplazarlo por completo.

Punto clave: La palabra clave parent:: proporciona una forma de acceder a la implementación de la clase padre. Es esencial para el encadenamiento adecuado de constructores y para construir sobre la funcionalidad heredada en lugar de reescribirla.

Desafío

Fácil

Vamos a construir un sistema de catálogo de productos que demuestre cómo las clases hijas pueden extender la funcionalidad de los padres utilizando la palabra clave parent:: para encadenar constructores correctamente y construir sobre los métodos heredados.

Organizarás tu código en tres archivos:

Product.php — Define una clase Product que sirva como base para todos los productos. Debe tener las propiedades públicas $name y $price. El constructor acepta un nombre y un precio, estableciendo ambas propiedades. Incluye un método getDetails() que devuelva "[name]: $[price]".
ElectronicProduct.php — Define una clase ElectronicProduct que extienda de Product. Incluye el archivo Product al principio. Esta clase añade una propiedad $warranty (en meses). El constructor debe aceptar el nombre, el precio y la garantía — utiliza parent::__construct() para inicializar el nombre y el precio a través del padre, y luego establece la garantía tú mismo. Crea un método getDetails() que se base en la implementación del padre: llama a parent::getDetails() y añade " (Warranty: [warranty] months)" al final.
main.php — Incluye el archivo ElectronicProduct. Recibirás tres entradas: el nombre del producto, el precio (como una cadena para convertir a float) y el periodo de garantía (como una cadena para convertir a entero). Crea un ElectronicProduct con estos valores e imprime el resultado de llamar a getDetails().

Este desafío muestra el verdadero poder de parent:: — no solo para el encadenamiento de constructores, sino también para extender el comportamiento de los métodos. Tu ElectronicProduct reutiliza la lógica de formato del padre y añade sus propios detalles encima, evitando la duplicación de código mientras crea una salida más rica.

Hoja de referencia

La palabra clave parent:: permite que una clase hija acceda a métodos y propiedades de su clase padre.

Usa parent::__construct() para llamar al constructor del padre desde la clase hija:

<?php
class Animal {
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
}

class Dog extends Animal {
    public $breed;
    
    public function __construct($name, $breed) {
        parent::__construct($name);
        $this->breed = $breed;
    }
}

También puedes usar parent:: para llamar a cualquier método del padre y extender su comportamiento:

<?php
class Animal {
    public function describe() {
        return "This is an animal";
    }
}

class Dog extends Animal {
    public function describe() {
        return parent::describe() . " and it's a dog";
    }
}

Este enfoque permite que las clases hijas reutilicen la lógica del padre en lugar de duplicar código, permitiendo un encadenamiento de constructores y una extensión de métodos adecuados.

Pruébalo tú mismo

<?php
require_once 'ElectronicProduct.php';

// Leer entradas
$name = trim(fgets(STDIN));
$price = floatval(trim(fgets(STDIN)));
$warranty = intval(trim(fgets(STDIN)));

// TODO: Crear un ElectronicProduct con los valores de entrada
// y mostrar el resultado de llamar a getDetails()

?>