Abschnitt 18 · Lektion 2
Vererbung
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
<p>Eine Basis, eine Ableitung, eine überschriebene Methode.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} 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
<p>Zweimal derselbe constructor, einmal in der falschen Reihenfolge.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} 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
<p>Der eine Fall, in dem Vererbung im Alltag wirklich nützt.</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
} 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 anErrorweiter, und sie landet infehler.message. Fehlt der Aufruf ganz, kommt derconstructornicht einmal bisthis.nameund wirft einenReferenceError. Einsuper()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 weiterError, 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, kostenlosZu 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.