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 Veicolo con 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.