Composizione o ereditarietà
Composizione o ereditarietà
Nella lezione sulla programmazione a oggetti (03 - Programmazione a oggetti, sezione 5) c'è un consiglio che troverete ovunque: "preferire la composizione all'ereditarietà". Detto così sembra una regola da imparare a memoria. Qui c'è un programma che cresce un pezzo alla volta finché l'ereditarietà si incastra, e poi lo stesso programma scritto con la composizione.
Il punto di partenza: un noleggio in città
Un comune noleggia bici e monopattini. Ogni mezzo ha un codice, e il programma deve stampare una scheda per ognuno. Con l'ereditarietà viene naturale:
abstract class Veicolo {
readonly codice: string;
constructor(codice: string) {
this.codice = codice;
}
abstract tipo(): string;
scheda(): string {
return `${this.tipo()} ${this.codice}`;
}
}
class Bici extends Veicolo {
tipo(): string {
return "Bici";
}
}
class Monopattino extends Veicolo {
tipo(): string {
return "Monopattino";
}
}
const parco: Veicolo[] = [new Bici("B-01"), new Monopattino("M-07")];
for (const v of parco) {
console.log(v.scheda());
}
// Bici B-01
// Monopattino M-07
"Una bici è un veicolo", "un monopattino è un veicolo": il test "è un" passa.
Arrivano i mezzi elettrici
Il comune compra bici elettriche e monopattini elettrici. Un mezzo elettrico ha una batteria: si scarica mentre lo usate, si ricarica, e la scheda deve dire quanti chilometri restano. "Una bici elettrica è una bici", quindi:
// Veicolo, Bici e Monopattino come nel blocco sopra
class BiciElettrica extends Bici {
private carica: number = 100;
private readonly autonomiaKm: number = 60;
kmRimasti(): number {
return Math.round((this.autonomiaKm * this.carica) / 100);
}
percorri(km: number): void {
this.carica = Math.max(this.carica - (km / this.autonomiaKm) * 100, 0);
}
scheda(): string {
return `${super.scheda()}, autonomia ${this.kmRimasti()} km`;
}
}
class MonopattinoElettrico extends Monopattino {
private carica: number = 100;
private readonly autonomiaKm: number = 25;
kmRimasti(): number {
return Math.round((this.autonomiaKm * this.carica) / 100);
}
percorri(km: number): void {
this.carica = Math.max(this.carica - (km / this.autonomiaKm) * 100, 0);
}
scheda(): string {
return `${super.scheda()}, autonomia ${this.kmRimasti()} km`;
}
}
const bici = new BiciElettrica("B-02");
bici.percorri(15);
console.log(bici.scheda()); // Bici B-02, autonomia 45 km
Guardate BiciElettrica e MonopattinoElettrico: a parte i numeri, sono identiche. La logica della batteria è scritta due volte, che è proprio il problema da cui l'ereditarietà doveva liberarci.
Viene l'idea di spostarla in una madre comune, VeicoloElettrico. Ma BiciElettrica ha già una madre, Bici, e in TypeScript una classe ne può avere una sola. O la bici elettrica eredita da Bici, o eredita da VeicoloElettrico. Tutte e due no.
Arriva il GPS
L'anno dopo il comune monta un GPS su alcuni mezzi, per ritrovarli quando qualcuno li lascia in giro. Alcuni, non tutti: anche alcune bici normali, e non tutte le elettriche. Seguendo la stessa strada, ogni combinazione diventa una classe:
| Senza GPS | Con GPS |
|---|---|
Bici |
BiciConGps |
BiciElettrica |
BiciElettricaConGps |
Monopattino |
MonopattinoConGps |
MonopattinoElettrico |
MonopattinoElettricoConGps |
Otto classi, e la logica del GPS ripetuta in quattro. Il comune aggiunge le cargo bike: altre quattro classi. Poi il seggiolino per bambini, che si può montare o no: ogni classe si sdoppia, e diventano ventiquattro. Ogni caratteristica nuova raddoppia le classi.
C'è anche un problema che nessuna gerarchia risolve. Se domani il comune monta il GPS su una bici che ha già, B-01, quella bici dovrebbe "cambiare classe" da Bici a BiciConGps. Un'istanza non può cambiare classe: si decide alla new e resta quella per sempre.
Dove si è rotto
Rileggete le frasi. "Una bici è un veicolo": vero, ed è giusto che Bici estenda Veicolo. "Una bici elettrica con il GPS è una bici elettrica": suona già strano. Le frasi che descrivono il comune sono altre:
- una bici elettrica ha una batteria;
- un monopattino con il GPS ha un GPS.
Batteria e GPS non sono "tipi di veicolo". Sono pezzi che si montano su un veicolo. E quando la frase giusta è "ha un", la soluzione è una proprietà.
La stessa cosa con la composizione
Ogni pezzo diventa una classe sua, che sa fare il suo lavoro e niente altro:
class Batteria {
private carica: number = 100;
private readonly autonomiaKm: number;
constructor(autonomiaKm: number) {
this.autonomiaKm = autonomiaKm;
}
kmRimasti(): number {
return Math.round((this.autonomiaKm * this.carica) / 100);
}
consuma(km: number): void {
this.carica = Math.max(this.carica - (km / this.autonomiaKm) * 100, 0);
}
ricarica(): void {
this.carica = 100;
}
}
class Gps {
private posizione: string;
constructor(posizione: string) {
this.posizione = posizione;
}
aggiorna(posizione: string): void {
this.posizione = posizione;
}
dove(): string {
return this.posizione;
}
}
abstract class Veicolo {
readonly codice: string;
private batteria?: Batteria;
private gps?: Gps;
constructor(codice: string) {
this.codice = codice;
}
abstract tipo(): string;
montaBatteria(batteria: Batteria): void {
this.batteria = batteria;
}
installaGps(gps: Gps): void {
this.gps = gps;
}
percorri(km: number, arrivo: string): void {
if (this.batteria) {
this.batteria.consuma(km);
}
if (this.gps) {
this.gps.aggiorna(arrivo);
}
}
scheda(): string {
let testo: string = `${this.tipo()} ${this.codice}`;
if (this.batteria) {
testo += `, autonomia ${this.batteria.kmRimasti()} km`;
}
if (this.gps) {
testo += `, si trova in ${this.gps.dove()}`;
}
return testo;
}
}
class Bici extends Veicolo {
tipo(): string {
return "Bici";
}
}
class Monopattino extends Veicolo {
tipo(): string {
return "Monopattino";
}
}
const normale = new Bici("B-01");
const elettrica = new Bici("B-02");
elettrica.montaBatteria(new Batteria(60));
const monopattino = new Monopattino("M-07");
monopattino.montaBatteria(new Batteria(25));
monopattino.installaGps(new Gps("Piazza Garibaldi"));
const parco: Veicolo[] = [normale, elettrica, monopattino];
elettrica.percorri(15, "Stazione");
monopattino.percorri(5, "Via Dante");
for (const v of parco) {
console.log(v.scheda());
}
// Bici B-01
// Bici B-02, autonomia 45 km
// Monopattino M-07, autonomia 20 km, si trova in Via Dante
normale.installaGps(new Gps("Deposito"));
console.log(normale.scheda()); // Bici B-01, si trova in Deposito
batteria? e gps? sono proprietà opzionali: un veicolo può averle o no. Per questo, prima di usarle, Veicolo controlla con un if che ci siano. Senza l'if il compilatore protesta: Object is possibly 'undefined'.
Veicolo non sa come si calcola l'autonomia. Quando gli serve, lo chiede alla batteria: this.batteria.kmRimasti(). Questo passaggio si chiama delega: l'oggetto passa il lavoro al pezzo che lo sa fare. La logica della batteria sta in un posto solo, Batteria, ed è la stessa per bici e monopattini, che cambiano solo l'autonomia passata al costruttore.
L'ereditarietà non è sparita. Bici e Monopattino estendono ancora Veicolo, perché lì la frase "è un" è vera. Abbiamo tolto l'ereditarietà solo dove la frase giusta era "ha un".
L'ultima riga fa quello che con la gerarchia era impossibile: monta il GPS su una bici che esisteva già, mentre il programma gira. La bici resta una Bici, ha solo un pezzo in più.
Il conto
| Con l'ereditarietà | Con la composizione | |
|---|---|---|
| Classi per 2 tipi di mezzo, batteria e GPS | 8 | 5 (Veicolo, Bici, Monopattino, Batteria, Gps) |
| Aggiungere un tipo di mezzo (cargo bike) | 4 classi nuove | 1 classe nuova |
| Aggiungere un accessorio (seggiolino) | Raddoppiano tutte le classi | 1 classe nuova, più una proprietà in Veicolo |
| Logica della batteria | Ripetuta in ogni classe elettrica | Scritta una volta, in Batteria |
| Montare il GPS su un mezzo esistente | Impossibile: l'istanza non cambia classe | installaGps(...) |
Quando l'ereditarietà va bene lo stesso
La composizione non è sempre la risposta. L'ereditarietà resta la scelta giusta quando:
- la frase "è un" è vera sempre, non solo oggi: una bici è un veicolo e lo sarà per tutta la vita del programma;
- la gerarchia è corta, uno o due livelli, come
Veicolocon le sue figlie; - le figlie hanno davvero molto codice in comune con la madre e cambiano solo qualche pezzo, come gli abbonamenti della palestra nella lezione.
Il segnale d'allarme sono i nomi delle classi. Quando cominciano a contenere "Con" o "E" (BiciElettricaConGps), state usando l'ereditarietà per mettere insieme caratteristiche, e quelle caratteristiche vogliono essere pezzi da comporre.
Nel corso di Design Pattern ritroverete questa idea molte volte: molti pattern sono modi ordinati di comporre oggetti invece di estenderli.