Os limites da herança profunda

Parte da seção Programação Orientada a Objetos do Journey de JavaScript da Coddy — lição 48 de 56.

Embora a herança seja útil, criar hierarquias de herança muito profundas (pai → filho → neto → bisneto) pode levar a problemas. Quanto mais profunda a cadeia, mais difícil se torna entender, manter e modificar o código.

Vamos ver o que acontece com uma cadeia de herança profunda:

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

// Primeiro nível de herança
class Car extends Vehicle {
  constructor(make, model) {
    super("Car");
    this.make = make;
    this.model = model;
    this.wheels = 4;
  }
  
  honk() {
    console.log("Beep beep!");
  }
}

// Segundo nível de herança
class SportsCar extends Car {
  constructor(make, model, topSpeed) {
    super(make, model);
    this.topSpeed = topSpeed;
  }
  
  race() {
    this.start();
    console.log(`Racing at ${this.topSpeed} mph!`);
  }
}

Neste exemplo, SportsCar está a dois níveis de profundidade na herança. Isso pode levar a vários problemas:

Alterações em Vehicle podem quebrar inesperadamente o SportsCar

À medida que a cadeia de herança cresce, torna-se mais difícil rastrear de onde vêm os métodos e propriedades

Você é forçado a aceitar relações do tipo "is-a" que podem não ser flexíveis o suficiente

Desafio

Complete o arquivo Robot.js para tornar o robô funcional. No momento, o robô está construído, mas não consegue fazer nada.

O que fazer em <strong>Robot.js</strong>:

Crie os componentes speaker e mover dentro do construtor Robot
Use os componentes nos métodos:
1. Em greet(): Chame this.speaker.speak("Hello!");
2. Em walkForward(): Chame this.mover.move("forward");

Por que fazemos isso: Isso é composição - o robô é construído combinando componentes menores. O robô tem-um speaker (para falar) e tem-um mover (para se mover), em vez de herdar essas habilidades.

Folha de consulta

Hierarquias de herança profundas (pai → filho → neto) podem levar a problemas de manutenção e inflexibilidade. Quanto mais profunda a cadeia, mais difícil se torna entender e modificar o código.

Exemplo de uma cadeia de herança 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 com herança profunda:

Alterações em classes base podem quebrar classes filhas inesperadamente
Difícil rastrear de onde se originam métodos e propriedades
Força relacionamentos rígidos do tipo "é-um" que carecem de flexibilidade

Composição como alternativa: Em vez de herança, use a composição onde os objetos têm um relacionamento do tipo tem-um com componentes, combinando partes menores para construir funcionalidades.

Experimente você mesmo

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

const myRobot = new Robot('Robo');

myRobot.greet();     // Deve exibir: Saying: "Hello!"
myRobot.walkForward(); // Deve exibir: Moving forward