mitmario.dev

Vererbung

JavaScript Im Browser 3 Min Lesezeit 3 BeispieleLektion 2 von 7

Ein geplanter Kurs ist ein Kurs wie jeder andere, nur mit einem Starttermin. Den gemeinsamen Teil zweimal zu schreiben, wäre lästig. Dafür gibt es extends.

extends und super

Eine Klasse auf einer anderen
class Kurs {
  constructor(titel, stunden) {
    this.titel = titel;
    this.stunden = stunden;
  }

  stand() {
    return "fertig";
  }

  beschreibung() {
    return `${this.titel}, ${this.stunden} h, ${this.stand()}`;
  }
}

class GeplanterKurs extends Kurs {
  constructor(titel, stunden, ab) {
    // super ruft den constructor der Basis auf.
    super(titel, stunden);
    this.ab = ab;
  }

  // Überschreibt stand, beschreibung bleibt geerbt.
  stand() {
    return `geplant ab ${this.ab}`;
  }
}

const fertig = new Kurs("JavaScript", 47);
const geplant = new GeplanterKurs("TypeScript", 30, "März");

console.log(fertig.beschreibung());
console.log(geplant.beschreibung());
console.log("Ist ein GeplanterKurs auch ein Kurs?", geplant instanceof Kurs);

class GeplanterKurs extends Kurs heißt, dass diese Klasse alles kann, was Kurs kann, und dazu etwas Eigenes.

super(...) im constructor ruft den constructor der Basisklasse auf. Was der erledigt, musst du nicht noch einmal schreiben.

Interessant ist im ersten Beispiel beschreibung(). Die Methode steht nur in der Basisklasse und ruft this.stand() auf. Bei einem geplanten Kurs landet dieser Aufruf trotzdem in der überschriebenen Fassung, denn die Methode weiß nicht, in welcher Klasse sie gerade arbeitet.

super() steht vor jedem this

super muss vor this stehen
class Basis {
  constructor(name) {
    this.name = name;
  }
}

class Richtig extends Basis {
  constructor(name) {
    super(name);
    this.gross = name.toUpperCase();
  }
}

class Falsch extends Basis {
  constructor(name) {
    // Vor super gibt es noch kein this.
    this.gross = name.toUpperCase();
    super(name);
  }
}

console.log("Richtig:", new Richtig("mario").gross);

try {
  console.log("Falsch:", new Falsch("mario").gross);
} catch (fehler) {
  console.error(fehler.name + ":", fehler.message);
}

Hier gilt eine harte Regel. Wer sie bricht, bekommt einen ReferenceError mit der Meldung Must call super constructor in derived class before accessing 'this' or returning from derived constructor. Auf Deutsch heißt das, dass super() vor jedem Zugriff auf this kommen muss.

Bei einer abgeleiteten Klasse legt new das Objekt nicht selbst an. Das macht der constructor der Basisklasse, und der läuft erst mit super(). Davor gibt es kein Objekt. Also auch kein this, auf das du etwas schreiben könntest.

Code, der this nicht anfasst, darf vor super() stehen, etwa eine Umrechnung der Argumente. Alles mit this kommt danach.

Wo Vererbung kippt

Vererbung sieht auf den ersten Blick nach Ordnung aus. In der dritten Ebene ist sie meistens keine mehr.

Das Problem steckt in der Behauptung dahinter. extends sagt, dieses Ding ist eines von jener Sorte, in jeder Hinsicht und für immer. Beim Schreiben stimmt das oft noch und ein Jahr später oft nicht mehr, und dann steht in der Basisklasse eine Methode, die für drei von fünf Ableitungen keinen Sinn ergibt.

Die Alternative heißt Zusammensetzen (englisch composition). Statt von einer Klasse zu erben, bekommt ein Objekt das, was es braucht, als Bestandteil mit. Das ist unspektakulär und hält länger.

Eine Ebene Vererbung ist meistens in Ordnung. Ab der zweiten frage ich mich, ob ich wirklich eine Ist-Beziehung beschreibe oder nur Code sparen wollte.

Der Fall, in dem sie wirklich nützt

Eigene Fehlerarten
class KursFehler extends Error {
  constructor(meldung, kennung) {
    super(meldung);
    this.name = "KursFehler";
    this.kennung = kennung;
  }
}

function holeKurs(kennung) {
  if (kennung !== "javascript") {
    throw new KursFehler(`Kurs nicht gefunden: ${kennung}`, kennung);
  }
  return { titel: "JavaScript" };
}

function versuchen(kennung) {
  try {
    console.log("Gefunden:", holeKurs(kennung).titel);
  } catch (fehler) {
    // Jetzt lässt sich der eigene Fehler vom Rest trennen.
    if (fehler instanceof KursFehler) {
      console.warn("Eigener Fehler:", fehler.message, "| Kennung:", fehler.kennung);
    } else {
      console.error("Fremder Fehler:", fehler.message);
    }
  }
}

versuchen("javascript");
versuchen("git");
console.log("name:", new KursFehler("x", "y").name);
console.log("Ist es ein Error?", new KursFehler("x", "y") instanceof Error);

Einen Fall gibt es im Alltag ständig, und dort ist Vererbung richtig. Es sind die eigenen Fehlerarten aus Lektion 14.3, diesmal als Klasse gebaut.

class KursFehler extends Error ergibt einen Fehler, der alles kann, was ein Error kann, und dazu eigene Eigenschaften trägt. Im catch kannst du ihn dann mit instanceof von allem anderen unterscheiden und deinen eigenen Fehler anders behandeln als einen, mit dem niemand gerechnet hat.

Zwei Kleinigkeiten gehören dazu.

  • super(meldung) gibt die Meldung an Error weiter, und sie landet in fehler.message. Fehlt der Aufruf ganz, kommt der constructor nicht einmal bis this.name und wirft einen ReferenceError. Ein super() ohne Argument lässt die Meldung leer.
  • this.name = "KursFehler" setzt den Namen, der in der Console vor der Meldung steht. Ohne diese Zeile steht dort weiter Error, und ausgerechnet das, wofür die Klasse gebaut wurde, fehlt in der Meldung.

Im dritten Beispiel ergibt console.error(new KursFehler("Kurs nicht gefunden: git", "git")) in der Eingabezeile der Console die Zeile KursFehler: Kurs nicht gefunden: git. So sieht auch ein Fehler aus, den niemand gefangen hat. Der Name ist das Erste, was man liest.

Name und Meldung sind dabei zwei verschiedene Dinge. Ein catch prüft die Art des Fehlers mit instanceof oder über fehler.name, nie über den Text der Meldung. Texte ändern sich, und in einer anderen Sprache stimmen sie ohnehin nicht mehr.

In der Aufgabe entstehen zwei Ableitungen, und die zweite ist ein eigener Fehler.

Zum Mitnehmen

extends baut eine Klasse auf einer anderen auf, und super() ruft deren constructor, bevor this benutzt wird. Im Alltag lohnt sich das vor allem für eigene Fehlerarten, die ein catch mit instanceof erkennt.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.