Los límites de la herencia profunda

Parte de la sección Programación Orientada a Objetos del Journey de JavaScript de Coddy — lección 48 de 56.

Si bien la herencia es útil, crear jerarquías de herencia muy profundas (padre → hijo → nieto → bisnieto) puede generar problemas. Cuanto más profunda sea la cadena, más difícil resultará comprender, mantener y modificar el código.

Veamos qué sucede con una cadena de herencia profunda:

// Base class
class Vehicle {
  constructor(type) {
    this.type = type;
    this.isRunning = false;
  }
  
  start() {
    this.isRunning = true;
    console.log(`${this.type} started`);
  }
}

// First level of inheritance
class Car extends Vehicle {
  constructor(make, model) {
    super("Car");
    this.make = make;
    this.model = model;
    this.wheels = 4;
  }
  
  honk() {
    console.log("Beep beep!");
  }
}

// Second level of inheritance
class SportsCar extends Car {
  constructor(make, model, topSpeed) {
    super(make, model);
    this.topSpeed = topSpeed;
  }
  
  race() {
    this.start();
    console.log(`Racing at ${this.topSpeed} mph!`);
  }
}

En este ejemplo, SportsCar tiene dos niveles de profundidad en la herencia. Esto puede dar lugar a varios problemas:

Los cambios en Vehicle podrían romper inesperadamente SportsCar

A medida que la cadena de herencia crece, se vuelve más difícil rastrear de dónde provienen los métodos y las propiedades

Te ves obligado a entablar relaciones "es-un" que podrían no ser lo suficientemente flexibles

Desafío

Completa el archivo Robot.js para que el robot sea funcional. En este momento, el robot está construido pero no puede hacer nada.

Qué hacer en <strong>Robot.js</strong>:

Crea los componentes speaker y mover dentro del constructor de Robot
Usa los componentes en los métodos:
1. En greet(): Llama a this.speaker.speak("Hello!");
2. En walkForward(): Llama a this.mover.move("forward");

Por qué hacemos esto: Esto es composición - el robot se construye combinando componentes más pequeños. El robot tiene-un (has-a) speaker (para hablar) y tiene-un (has-a) mover (para moverse), en lugar de heredar estas habilidades.

Hoja de referencia

Las jerarquías de herencia profundas (padre → hijo → nieto) pueden provocar problemas de mantenimiento e inflexibilidad. Cuanto más profunda es la cadena, más difícil resulta comprender y modificar el código.

Ejemplo de una cadena de herencia profunda:

class Vehicle {
  constructor(type) {
    this.type = type;
    this.isRunning = false;
  }
  
  start() {
    this.isRunning = true;
    console.log(`${this.type} started`);
  }
}

class Car extends Vehicle {
  constructor(make, model) {
    super("Car");
    this.make = make;
    this.model = model;
  }
}

class SportsCar extends Car {
  constructor(make, model, topSpeed) {
    super(make, model);
    this.topSpeed = topSpeed;
  }
}

Problemas con la herencia profunda:

Los cambios en las clases base pueden romper inesperadamente las clases hijas
Es difícil rastrear dónde se originan los métodos y las propiedades
Fuerza relaciones rígidas de tipo "es-un" (is-a) que carecen de flexibilidad

La composición como alternativa: En lugar de la herencia, utilice la composición donde los objetos tienen una relación de tipo "tiene-un" (have-a) con los componentes, combinando partes más pequeñas para construir la funcionalidad.

Pruébalo tú mismo

import { Robot } from './Robot.js';

const myRobot = new Robot('Robo');

myRobot.greet();     // Debería mostrar: Saying: "Hello!"
myRobot.walkForward(); // Debería mostrar: Moving forward