Ereditarietà, super e quando preferire la composizione
Estendi una classe base con extends, chiami super nei costruttori, sovrascrivi i metodi in sicurezza e impari quando è preferibile una semplice composizione.
Ereditarietà, super e quando preferire la composizione è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento JavaScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso JavaScript Academy include 3 lezioni in totale.
Panoramica
Obiettivo: usi l'ereditarietà di base senza confusione.
- extends crea una classe figlia
- super(...) chiama il costruttore della classe genitore
- Sovrascriva un metodo; può chiamare facoltativamente super.method()
- Se non si tratta di una relazione is-a, preferisca la composizione
extends + super
Crei una classe figlia con extends; chiami super(name) per eseguire il costruttore della classe genitore e configurare this.
// Base class with a small field and method
class Animal {
constructor(name) {
this.name = name;
}
info() {
return "Animal:" + this.name;
}
}
// Child class extends the base and calls super(...)
class Dog extends Animal {
constructor(name, breed) {
// must call super() before using this
super(name);
this.breed = breed;
}
speak() {
return "woof";
}
}
const d = new Dog("Milo", "Beagle");
console.log(d.info(), d.speak());
Sovrascrittura di un metodo
Quando sovrascrive un metodo, può chiamare super.method() per riutilizzare la logica di base e poi aggiungere la propria modifica.
// Override a method; keep parent behavior with super.method()
class Button {
click() {
return "base-click";
}
}
class IconButton extends Button {
click() {
// call parent behavior, then add something
const base = super.click();
return base + "+icon";
}
}
const b = new IconButton();
console.log(b.click()); // "base-click+icon"
Preferisca la composizione per le relazioni has-a
Se la relazione è has-a (utilizza un helper), preferisca la composizione all'ereditarietà per mantenere semplici le classi.
// Composition: use a helper object instead of extending
class Logger {
log(msg) {
console.log("[log]", msg);
}
}
class Player {
constructor(name, logger) {
this.name = name;
this.logger = logger; // has-a logger
}
score(points) {
this.logger.log(this.name + " +" + points);
}
}
const logger = new Logger();
const p = new Player("Ayla", logger);
p.score(5);
is-a e has-a
L'ereditarietà modella una relazione is-a: un Dog è un Animal. La composizione è adatta agli helper has-a.
// Use instanceof for a quick is-a check
console.log("Dog is Animal?", d instanceof Animal);
console.log("Player is Animal?", p instanceof Animal);
Abitudini per chi è alle prime armi
Suggerimenti:
- Mantenga le gerarchie poco profonde per chi è alle prime armi.
- Chiami super(...) per primo nei costruttori delle sottoclassi.
- Sovrascriva solo ciò che serve; riutilizzi la logica con super.method().
- Preferisca la composizione per le utilità e le funzionalità trasversali.
Quiz sulle basi di super(...)
Verifica rapida: super nel costruttore di una sottoclasse.
Riepilogo
Riepilogo: usi extends per le vere relazioni is-a, chiami presto super(...), sovrascriva con attenzione (chiami super.method() quando è utile) e preferisca la composizione per gli helper.
Domande Frequenti
La lezione «Ereditarietà, super e quando preferire la composizione» è gratuita?
Sì — il testo completo di «Ereditarietà, super e quando preferire la composizione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso JavaScript Academy, passa a CoddyKit PRO. Il corso JavaScript Academy include 3 lezioni in totale.
Cosa imparerò in «Ereditarietà, super e quando preferire la composizione»?
Estendi una classe base con extends, chiami super nei costruttori, sovrascrivi i metodi in sicurezza e impari quando è preferibile una semplice composizione. Eserciti JavaScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare JavaScript Academy?
Non è richiesta alcuna esperienza precedente. JavaScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.
Quanto tempo richiede la lezione «Ereditarietà, super e quando preferire la composizione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione JavaScript Academy?
Sì. Ogni lezione JavaScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Campi delle classi, campi privati #, membri statici
- Ereditarietà, super e quando preferire la composizione
- Mixin (assaggio) — riuso semplice senza gerarchie profonde