Die Grenzen tiefer Vererbung

Teil des Abschnitts Objektorientierte Programmierung der JavaScript-Journey von Coddy — Lektion 48 von 56.

Während Vererbung nützlich ist, kann das Erstellen sehr tiefer Vererbungshierarchien (Eltern → Kind → Enkel → Urenkel) zu Problemen führen. Je tiefer die Kette ist, desto schwieriger wird es, den Code zu verstehen, zu warten und zu ändern.

Schauen wir uns an, was bei einer tiefen Vererbungskette passiert:

// 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!`);
  }
}

In diesem Beispiel ist SportsCar zwei Ebenen tief in der Vererbung. Dies kann zu mehreren Problemen führen:

Änderungen an Vehicle könnten unerwartet zu Fehlern in SportsCar führen

Mit zunehmender Länge der Vererbungskette wird es schwieriger nachzuvollziehen, woher Methoden und Eigenschaften stammen

Sie werden in „is-a“-Beziehungen gezwungen, die möglicherweise nicht flexibel genug sind.

Aufgabe

Vervollständige die Datei Robot.js, um den Roboter funktionsfähig zu machen. Im Moment ist der Roboter zwar gebaut, kann aber noch nichts tun.

Was in <strong>Robot.js</strong> zu tun ist:

Erstelle die Speaker- und Mover-Komponenten innerhalb des Robot-Konstruktors
Verwende die Komponenten in den Methoden:
1. In greet(): Rufe this.speaker.speak("Hello!"); auf
2. In walkForward(): Rufe this.mover.move("forward"); auf

Warum wir das tun: Das ist Komposition – der Roboter wird durch das Kombinieren kleinerer Komponenten gebaut. Der Roboter hat einen Speaker (zum Sprechen) und hat einen Mover (zum Bewegen), anstatt diese Fähigkeiten zu erben.

Spickzettel

Tiefe Vererbungshierarchien (Eltern → Kind → Enkelkind) können zu Wartungsproblemen und Unflexibilität führen. Je tiefer die Kette ist, desto schwieriger wird es, den Code zu verstehen und zu ändern.

Beispiel einer tiefen Vererbungskette:

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;
  }
}

Probleme mit tiefer Vererbung:

Änderungen an Basisklassen können unerwartet Kindklassen beeinträchtigen
Es ist schwierig nachzuvollziehen, woher Methoden und Eigenschaften stammen
Erzwingt starre „ist-ein“-Beziehungen, denen es an Flexibilität mangelt

Komposition als Alternative: Verwenden Sie anstelle von Vererbung die Komposition, bei der Objekte eine hat-ein-Beziehung zu Komponenten haben und kleinere Teile kombinieren, um Funktionalität aufzubauen.

Probier es selbst

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

const myRobot = new Robot('Robo');

myRobot.greet();     // Sollte ausgeben: Saying: "Hello!"
myRobot.walkForward(); // Sollte ausgeben: Moving forward