03 - Programmazione a oggetti
Programmazione a oggetti
Questa parte continua dalle classi della lezione precedente: istanze, new, this, private, getter e readonly. Il ripasso è nelle sezioni 4 e 5 di 02 - Funzioni e oggetti.
Le quattro idee nuove sono l'ereditarietà, il polimorfismo, le classi astratte e le interfacce. Tutte rispondono alla stessa domanda: come faccio a far lavorare insieme classi diverse senza riscrivere lo stesso codice più volte?
1. Ereditarietà
Il problema: codice ripetuto
Un'app di streaming ha un catalogo con film ed episodi di serie. Ogni film ha un titolo, una durata e un regista. Ogni episodio ha un titolo, una durata, la serie a cui appartiene e il suo numero. Con quello che sapete già, scrivete due classi:
class Film {
titolo: string;
durataMinuti: number;
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
this.regista = regista;
}
durataFormattata(): string {
const ore: number = Math.floor(this.durataMinuti / 60);
const minuti: number = this.durataMinuti % 60;
return `${ore}h ${minuti}min`;
}
}
class Episodio {
titolo: string;
durataMinuti: number;
serie: string;
numero: number;
constructor(titolo: string, durataMinuti: number, serie: string, numero: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
this.serie = serie;
this.numero = numero;
}
durataFormattata(): string {
const ore: number = Math.floor(this.durataMinuti / 60);
const minuti: number = this.durataMinuti % 60;
return `${ore}h ${minuti}min`;
}
}
const film = new Film("La vita è bella", 116, "Roberto Benigni");
const episodio = new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora", 3);
console.log(film.durataFormattata()); // 1h 56min
console.log(episodio.durataFormattata()); // 0h 28min
titolo, durataMinuti, le due righe del costruttore che le riempiono e tutto il metodo durataFormattata sono scritti due volte, identici. È lo stesso problema che le funzioni risolvevano per i calcoli ripetuti. Se domani aggiungete i documentari, li scrivete tre volte. Se trovate un errore in durataFormattata, lo correggete in tre punti.
Film ed episodi hanno una parte in comune perché sono tutti e due contenuti del catalogo. L'ereditarietà serve a scrivere quella parte una volta sola.
extends
Si scrive una classe con la parte comune, e le altre classi la estendono:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
durataFormattata(): string {
const ore: number = Math.floor(this.durataMinuti / 60);
const minuti: number = this.durataMinuti % 60;
return `${ore}h ${minuti}min`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
}
class Episodio extends Contenuto {
serie: string;
numero: number;
constructor(titolo: string, durataMinuti: number, serie: string, numero: number) {
super(titolo, durataMinuti);
this.serie = serie;
this.numero = numero;
}
}
const film = new Film("La vita è bella", 116, "Roberto Benigni");
const episodio = new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora", 3);
console.log(film.durataFormattata()); // 1h 56min
console.log(episodio.durataFormattata()); // 0h 28min
console.log(film.titolo); // La vita è bella
console.log(film.regista); // Roberto Benigni
class Film extends Contenuto vuol dire: un Film ha tutto quello che ha un Contenuto, più quello che scrivo qui dentro. Film non dichiara titolo né durataFormattata, eppure film.titolo e film.durataFormattata() funzionano: li eredita da Contenuto.
Le parole che troverete:
| Classe | Si chiama anche |
|---|---|
Contenuto, quella che viene estesa |
classe madre, classe base, superclasse |
Film ed Episodio, quelle che estendono |
classi figlie, classi derivate, sottoclassi |
Una classe può estendere una sola madre. Una madre può avere quante figlie volete.
Cosa si eredita
| Della madre | Nella figlia |
|---|---|
| Proprietà pubbliche | Ci sono, e si usano come se fossero della figlia |
| Metodi pubblici | Ci sono, e si chiamano come se fossero della figlia |
Proprietà e metodi private |
Ci sono nell'istanza, ma il codice della figlia non li può usare (vedi protected più sotto) |
| Costruttore | Se la figlia non ne scrive uno, usa quello della madre. Se lo scrive, deve chiamare quello della madre con super(...) |
L'ultima riga vuol dire che una figlia che non aggiunge proprietà può essere cortissima:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
}
class Documentario extends Contenuto {}
const doc = new Documentario("Il pianeta blu", 50);
console.log(doc.titolo); // Il pianeta blu
Documentario non scrive niente, quindi new Documentario(...) usa il costruttore di Contenuto, con gli stessi parametri.
super(...) nel costruttore
Nel costruttore della figlia, super(...) chiama il costruttore della madre. È lui che riempie titolo e durataMinuti. La figlia poi riempie le proprietà che ha aggiunto lei.
Due regole, controllate dal compilatore:
- Se la figlia ha un costruttore, deve chiamare
super(...), con gli argomenti che il costruttore della madre si aspetta. super(...)va chiamato prima di usarethis. Prima si costruisce la parte della madre, poi quella della figlia.
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) { // errore: Constructors for derived classes must contain a 'super' call.
this.regista = regista; // errore: 'super' must be called before accessing 'this' in the constructor of a derived class.
}
}
Anche gli argomenti sbagliati vengono fermati. Con super(titolo) il compilatore risponde Expected 2 arguments, but got 1., come per qualsiasi funzione.
Metodi propri della figlia
Una figlia può aggiungere metodi che la madre non ha. Un episodio, per esempio, può costruire la sua etichetta con il nome della serie:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
}
class Episodio extends Contenuto {
serie: string;
numero: number;
constructor(titolo: string, durataMinuti: number, serie: string, numero: number) {
super(titolo, durataMinuti);
this.serie = serie;
this.numero = numero;
}
etichetta(): string {
return `${this.serie}, ep. ${this.numero}: ${this.titolo}`;
}
}
class Film extends Contenuto {}
const episodio = new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora", 3);
console.log(episodio.etichetta()); // Cucina in mezz'ora, ep. 3: Risotto alla zucca
const film = new Film("La vita è bella", 116);
film.etichetta(); // errore: Property 'etichetta' does not exist on type 'Film'.
Dentro etichetta la figlia usa this.titolo, che ha ereditato, insieme a this.serie, che è sua. L'ereditarietà va in una direzione sola: la figlia riceve tutto dalla madre, la madre e le sorelle non ricevono niente dalla figlia. Film non ha etichetta.
Override: ridefinire un metodo
A volte la figlia ha un metodo con lo stesso nome della madre, ma deve farlo in un altro modo. Tutti i contenuti hanno una descrizione, ma quella di un film parla del regista e quella di un episodio della serie. La figlia può ridefinire il metodo: si dice che fa l'override.
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
descrivi(): string {
return `${this.titolo} (${this.durataMinuti} min)`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
descrivi(): string {
return `${super.descrivi()}, regia di ${this.regista}`;
}
}
class Episodio extends Contenuto {
serie: string;
numero: number;
constructor(titolo: string, durataMinuti: number, serie: string, numero: number) {
super(titolo, durataMinuti);
this.serie = serie;
this.numero = numero;
}
descrivi(): string {
return `${this.serie}, ep. ${this.numero}: ${super.descrivi()}`;
}
}
class Documentario extends Contenuto {}
console.log(new Film("La vita è bella", 116, "Roberto Benigni").descrivi());
// La vita è bella (116 min), regia di Roberto Benigni
console.log(new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora", 3).descrivi());
// Cucina in mezz'ora, ep. 3: Risotto alla zucca (28 min)
console.log(new Documentario("Il pianeta blu", 50).descrivi());
// Il pianeta blu (50 min)
Quando chiamate descrivi() su un film, parte la versione di Film. Su un documentario parte quella di Contenuto, perché Documentario non l'ha ridefinita.
Dentro un metodo della figlia, super.descrivi() chiama la versione della madre. Serve quando la figlia non vuole buttare il lavoro della madre ma aggiungerci qualcosa: il film prende la descrizione di base e ci attacca il regista. Senza super., this.descrivi() chiamerebbe di nuovo la versione del film, che chiamerebbe sé stessa all'infinito.
Il metodo ridefinito deve restare compatibile con quello della madre: stesso nome, parametri che la madre accetterebbe, stesso tipo di ritorno. Se in Film scrivete descrivi(): number, il compilatore risponde Property 'descrivi' in type 'Film' is not assignable to the same property in base type 'Contenuto'. Il motivo sta nella sezione 2: chi usa un Contenuto deve poter contare su descrivi() che restituisce una stringa, qualunque contenuto sia.
overridePotete scrivere override descrivi(): string { ... }. Funziona allo stesso modo, ma il compilatore controlla che la madre abbia davvero un metodo descrivi. Se sbagliate a scrivere il nome (descrive), invece di creare in silenzio un metodo nuovo vi segnala l'errore. Molti progetti la rendono obbligatoria.
protected: privato, ma visibile alle figlie
Il catalogo tiene il conto dei minuti che avete già visto. È un dato che da fuori non si deve poter cambiare a mano, quindi lo fate private, come il saldo del salvadanaio. Poi però una figlia ne ha bisogno:
class Contenuto {
titolo: string;
durataMinuti: number;
private minutiVisti: number = 0;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
guarda(minuti: number): void {
this.minutiVisti = Math.min(this.minutiVisti + minuti, this.durataMinuti);
}
}
class Episodio extends Contenuto {
finito(): boolean {
return this.minutiVisti === this.durataMinuti; // errore: Property 'minutiVisti' is private and only accessible within class 'Contenuto'.
}
}
private vuol dire "solo dentro questa classe", e la figlia è un'altra classe. Per dare accesso alle figlie e continuare a chiudere fuori il resto del programma c'è protected:
class Contenuto {
titolo: string;
durataMinuti: number;
protected minutiVisti: number = 0;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
guarda(minuti: number): void {
this.minutiVisti = Math.min(this.minutiVisti + minuti, this.durataMinuti);
}
}
class Episodio extends Contenuto {
finito(): boolean {
return this.minutiVisti === this.durataMinuti; // va bene: Episodio è una figlia
}
}
const episodio = new Episodio("Risotto alla zucca", 28);
episodio.guarda(20);
console.log(episodio.finito()); // false
episodio.guarda(10);
console.log(episodio.finito()); // true
episodio.minutiVisti = 0; // errore: Property 'minutiVisti' is protected and only accessible within class 'Contenuto' and its subclasses.
Le tre parole insieme:
| Dentro la classe | Dentro le figlie | Fuori | |
|---|---|---|---|
(niente, public) |
Sì | Sì | Sì |
protected |
Sì | Sì | No |
private |
Sì | No | No |
Partite da private e passate a protected solo quando una figlia ne ha bisogno. Ogni cosa protected è una cosa che tutte le figlie, anche quelle scritte da altri tra un anno, potranno toccare.
Il test "è un"
Prima di scrivere extends, provate la frase "un film è un contenuto". Se è vera, l'ereditarietà probabilmente va bene, e lo stesso vale per episodi e documentari.
I sottotitoli di un film hanno una lingua e un titolo, e viene la tentazione di riusare Contenuto per non riscrivere titolo:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
}
// Sbagliato: compila, ma non ha senso
class Sottotitoli extends Contenuto {
lingua: string;
constructor(titolo: string, lingua: string) {
super(titolo, 0);
this.lingua = lingua;
}
}
Il compilatore non dice niente. Ma "i sottotitoli sono un contenuto" è falso: non si guardano da soli, non hanno una durata (infatti passiamo 0 a caso), non stanno nel catalogo. I sottotitoli appartengono a un film: il film ha dei sottotitoli. Quando la frase giusta è "ha un", la soluzione non è extends ma una proprietà. Ci torniamo nella sezione 5.
instanceof: di che classe è?
instanceof controlla, mentre il programma gira, se un'istanza è stata creata da una classe o da una sua figlia. Restituisce un boolean:
class Contenuto {
titolo: string;
constructor(titolo: string) {
this.titolo = titolo;
}
}
class Film extends Contenuto {}
class Episodio extends Contenuto {}
const film = new Film("La vita è bella");
console.log(film instanceof Film); // true
console.log(film instanceof Contenuto); // true: un film è un contenuto
console.log(film instanceof Episodio); // false
La seconda riga è il test "è un" fatto dalla macchina: ogni Film è anche un Contenuto. Nella sezione 2 vedrete quando instanceof è la scelta giusta, e quando invece è il segno che manca un override.
Lato macchina: un'istanza sola, con le parti di tutte e due
new Film(...) crea un oggetto, non due. Non c'è un Contenuto da una parte e un Film dall'altra: c'è un solo spazio, altrove, che contiene le proprietà della madre e quelle della figlia.
class Contenuto {
titolo: string;
durataMinuti: number;
protected minutiVisti: number = 0;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
guarda(minuti: number): void {
this.minutiVisti = Math.min(this.minutiVisti + minuti, this.durataMinuti);
}
descrivi(): string {
return `${this.titolo} (${this.durataMinuti} min)`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
descrivi(): string {
return `${super.descrivi()}, regia di ${this.regista}`;
}
}
const film = new Film("La vita è bella", 116, "Roberto Benigni");
film.guarda(40);
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | film |
→ 500 |
| 500 | Film { titolo: "La vita è bella", durataMinuti: 116, minutiVisti: 40, regista: "Roberto Benigni" } |
Il costruttore lavora così:
newriserva lo spazio alla cella 500, e dentro il costruttore diFilmthisvale → 500.super(titolo, durataMinuti)esegue il costruttore diContenutosullo stesso spazio: anche lìthisvale → 500. Riempietitolo,durataMinutieminutiVisti.- Si torna nel costruttore di
Film, che riempieregistanella stessa cella 500.
Per questo super(...) deve venire prima di this: finché la madre non ha preparato la sua parte, lo spazio non è pronto.
E i metodi? Come nella lezione precedente, il codice non si copia nelle istanze. Sta una volta sola, con la sua classe:
| Classe | Metodi scritti lì |
|---|---|
Contenuto |
guarda, descrivi |
Film |
descrivi |
Quando scrivete film.guarda(40), il programma cerca guarda nella classe dell'istanza, Film. Non lo trova, e sale alla madre, Contenuto, dove c'è. Con film.descrivi() lo trova subito in Film e si ferma lì: per questo l'override "copre" il metodo della madre. super.descrivi() dice invece di saltare la figlia e cercare direttamente nella madre.
10-ereditarieta.ipynb2. Polimorfismo
Una variabile del tipo madre, un'istanza della figlia
Un film è un contenuto. Il compilatore lo sa, e vi lascia mettere un Film dove è previsto un Contenuto:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
descrivi(): string {
return `${this.titolo} (${this.durataMinuti} min)`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
descrivi(): string {
return `${super.descrivi()}, regia di ${this.regista}`;
}
}
const c: Contenuto = new Film("La vita è bella", 116, "Roberto Benigni");
console.log(c.titolo); // La vita è bella
console.log(c.descrivi()); // La vita è bella (116 min), regia di Roberto Benigni
console.log(c.regista); // errore: Property 'regista' does not exist on type 'Contenuto'.
Nelle ultime tre righe c'è tutto il polimorfismo.
- Il tipo della variabile è
Contenuto. Il compilatore vi fa usare solo quello che ha ogni contenuto:titolo,durataMinuti,descrivi. Nonregista, perché non tutti i contenuti ce l'hanno. - L'istanza però è un
Film. Quando il programma gira e chiamatec.descrivi(), parte la versione del film, quella con il regista.
Il tipo della variabile decide cosa potete chiamare. L'istanza decide quale versione parte.
Il contrario non si può fare. Un contenuto qualsiasi non è per forza un film:
class Contenuto {
titolo: string;
constructor(titolo: string) {
this.titolo = titolo;
}
}
class Film extends Contenuto {
regista: string = "";
}
const f: Film = new Contenuto("Il pianeta blu"); // errore: Property 'regista' is missing in type 'Contenuto' but required in type 'Film'.
Polimorfismo vuol dire "molte forme": la stessa chiamata, c.descrivi(), fa cose diverse a seconda dell'istanza che c'è dietro.
Un array di oggetti diversi
Il catalogo è un Contenuto[], e ci stanno film, episodi e documentari insieme:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
descrivi(): string {
return `${this.titolo} (${this.durataMinuti} min)`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
descrivi(): string {
return `${super.descrivi()}, regia di ${this.regista}`;
}
}
class Episodio extends Contenuto {
serie: string;
numero: number;
constructor(titolo: string, durataMinuti: number, serie: string, numero: number) {
super(titolo, durataMinuti);
this.serie = serie;
this.numero = numero;
}
descrivi(): string {
return `${this.serie}, ep. ${this.numero}: ${super.descrivi()}`;
}
}
class Documentario extends Contenuto {}
const listaDaVedere: Contenuto[] = [
new Film("La vita è bella", 116, "Roberto Benigni"),
new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora", 3),
new Documentario("Il pianeta blu", 50),
new Episodio("Tiramisù", 25, "Cucina in mezz'ora", 4),
];
let totale: number = 0;
for (const c of listaDaVedere) {
console.log(c.descrivi());
totale += c.durataMinuti;
}
console.log(`Totale: ${totale} minuti`);
// La vita è bella (116 min), regia di Roberto Benigni
// Cucina in mezz'ora, ep. 3: Risotto alla zucca (28 min)
// Il pianeta blu (50 min)
// Cucina in mezz'ora, ep. 4: Tiramisù (25 min)
// Totale: 219 minuti
Il ciclo non sa, e non gli interessa sapere, che cosa c'è in ogni posizione. Chiede a ogni elemento di descriversi, e ognuno lo fa a modo suo.
Perché è utile: aggiungere un tipo senza toccare il ciclo
Il catalogo si allarga ai concerti, con l'artista e la città. Senza polimorfismo il ciclo dovrebbe sapere come è fatto ogni tipo di contenuto:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
}
class Episodio extends Contenuto {
serie: string;
constructor(titolo: string, durataMinuti: number, serie: string) {
super(titolo, durataMinuti);
this.serie = serie;
}
}
const listaDaVedere: Contenuto[] = [
new Film("La vita è bella", 116, "Roberto Benigni"),
new Episodio("Risotto alla zucca", 28, "Cucina in mezz'ora"),
];
// Da non fare: un if per ogni tipo
for (const c of listaDaVedere) {
if (c instanceof Film) {
console.log(`${c.titolo}, regia di ${c.regista}`);
} else if (c instanceof Episodio) {
console.log(`${c.serie}: ${c.titolo}`);
} else {
console.log(c.titolo);
}
}
Funziona, ma ogni tipo nuovo vuol dire un else if in più, e non solo qui: in ogni punto del programma che stampa, filtra o ordina i contenuti. Prima o poi un punto ve lo dimenticate, e i concerti escono descritti male.
Con l'override, il concerto si descrive da solo. Basta scrivere la classe nuova:
class Contenuto {
titolo: string;
durataMinuti: number;
constructor(titolo: string, durataMinuti: number) {
this.titolo = titolo;
this.durataMinuti = durataMinuti;
}
descrivi(): string {
return `${this.titolo} (${this.durataMinuti} min)`;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, durataMinuti: number, regista: string) {
super(titolo, durataMinuti);
this.regista = regista;
}
descrivi(): string {
return `${super.descrivi()}, regia di ${this.regista}`;
}
}
// La classe nuova: è l'unica cosa da scrivere
class Concerto extends Contenuto {
artista: string;
citta: string;
constructor(titolo: string, durataMinuti: number, artista: string, citta: string) {
super(titolo, durataMinuti);
this.artista = artista;
this.citta = citta;
}
descrivi(): string {
return `${this.artista} dal vivo a ${this.citta}: ${super.descrivi()}`;
}
}
const listaDaVedere: Contenuto[] = [
new Film("La vita è bella", 116, "Roberto Benigni"),
new Concerto("Tour d'estate", 95, "I Lampioni", "Bari"),
];
// Il ciclo è lo stesso di prima, non è cambiato niente
for (const c of listaDaVedere) {
console.log(c.descrivi());
}
// La vita è bella (116 min), regia di Roberto Benigni
// I Lampioni dal vivo a Bari: Tour d'estate (95 min)
Il codice che usa i contenuti non cambia quando arriva un tipo nuovo. Cambia solo il codice che descrive il tipo nuovo, e sta tutto in una classe. È il vantaggio principale del polimorfismo.
Quando instanceof serve davvero
A volte vi serve proprio una cosa che solo un tipo ha: per esempio, mostrare i registi dei film del catalogo. Qui instanceof va bene, e il compilatore lo capisce: dentro l'if, sa che c è un Film e vi lascia usare regista.
class Contenuto {
titolo: string;
constructor(titolo: string) {
this.titolo = titolo;
}
}
class Film extends Contenuto {
regista: string;
constructor(titolo: string, regista: string) {
super(titolo);
this.regista = regista;
}
}
class Documentario extends Contenuto {}
const listaDaVedere: Contenuto[] = [
new Film("La vita è bella", "Roberto Benigni"),
new Documentario("Il pianeta blu"),
new Film("Il postino", "Michael Radford"),
];
const registi: string[] = [];
for (const c of listaDaVedere) {
if (c instanceof Film) {
registi.push(c.regista); // qui c è un Film
}
}
console.log(registi); // [ 'Roberto Benigni', 'Michael Radford' ]
La regola pratica: se vi trovate a scrivere una catena di if (... instanceof ...) che fa la stessa cosa in modo diverso per ogni tipo, quella cosa è un metodo da ridefinire in ogni figlia.
Lato macchina: l'istanza sa di che classe è
Nella tabella della memoria, ogni istanza porta con sé il nome della sua classe. È scritto lì dalla new, e non cambia più:
// le classi sono quelle di "Un array di oggetti diversi"
const listaDaVedere: Contenuto[] = [
new Film("La vita è bella", 116, "Roberto Benigni"),
new Documentario("Il pianeta blu", 50),
];
| Indirizzo | Nome | Contenuto |
|---|---|---|
| 100 | listaDaVedere |
→ 500 |
| 500 | [→ 600, → 700] |
|
| 600 | Film { titolo: "La vita è bella", durataMinuti: 116, regista: "Roberto Benigni" } |
|
| 700 | Documentario { titolo: "Il pianeta blu", durataMinuti: 50 } |
Quando il ciclo esegue c.descrivi():
ccontiene una freccia, per esempio → 600.- Il programma va alla cella 600 e legge di che classe è l'istanza:
Film. - Cerca
descriviinFilm, lo trova, lo esegue conthisuguale a → 600.
Al giro dopo c vale → 700. L'istanza è un Documentario, che non ha descrivi; il programma sale a Contenuto e trova lì il metodo.
Il punto da capire è quando viene fatta questa scelta. Il compilatore, prima che il programma parta, guarda solo il tipo della variabile: c è un Contenuto, Contenuto ha descrivi, quindi la chiamata è permessa. Quale descrivi eseguire lo decide il programma mentre gira, istanza per istanza, leggendo la classe scritta nella memoria. Il compilatore non potrebbe saperlo: l'array potrebbe essere riempito con quello che sceglie l'utente.
| Chi | Quando | Cosa guarda | Cosa decide |
|---|---|---|---|
| Il compilatore | Prima di partire | Il tipo della variabile | Se la chiamata è permessa |
| Il programma | Mentre gira | La classe dell'istanza | Quale versione del metodo eseguire |
11-polimorfismo-e-classi-astratte.ipynb3. Classi astratte
Una classe che non deve esistere da sola
Una palestra vende tre tipi di abbonamento:
| Abbonamento | Prezzo al mese |
|---|---|
| Base | 35 € |
| Studenti | 25 € |
| Con corsi | 35 € più 8 € per ogni corso scelto |
Tutti gli abbonamenti hanno un intestatario, un costo annuale (dodici volte il prezzo al mese) e un riepilogo da stampare. Il prezzo al mese invece si calcola in modo diverso per ognuno. Con l'ereditarietà della sezione 1 scrivete una madre Abbonamento con la parte comune. Ma che prezzo mettete nella madre?
Un abbonamento "e basta", che non sia né base né studenti né con corsi, alla palestra non esiste. Non ha un prezzo sensato. Qualsiasi numero scriviate nella madre è inventato, e se qualcuno crea per sbaglio un new Abbonamento(...) paga una cifra a caso.
Una classe astratta è una madre che dice: "non create istanze di me; create le mie figlie". Può anche lasciare dei metodi senza corpo, che ogni figlia è obbligata a scrivere.
abstract class e metodi astratti
abstract class Abbonamento {
readonly intestatario: string;
constructor(intestatario: string) {
this.intestatario = intestatario;
}
abstract prezzoMensile(): number;
costoAnnuale(): number {
return this.prezzoMensile() * 12;
}
riepilogo(): string {
return `${this.intestatario}: ${this.prezzoMensile()} € al mese, ${this.costoAnnuale()} € all'anno`;
}
}
class AbbonamentoBase extends Abbonamento {
prezzoMensile(): number {
return 35;
}
}
class AbbonamentoStudenti extends Abbonamento {
prezzoMensile(): number {
return 25;
}
}
class AbbonamentoConCorsi extends Abbonamento {
private corsi: string[];
constructor(intestatario: string, corsi: string[]) {
super(intestatario);
this.corsi = corsi;
}
prezzoMensile(): number {
return 35 + 8 * this.corsi.length;
}
}
const iscritti: Abbonamento[] = [
new AbbonamentoBase("Ada"),
new AbbonamentoStudenti("Linus"),
new AbbonamentoConCorsi("Grace", ["yoga", "pilates"]),
];
let incassoMensile: number = 0;
for (const a of iscritti) {
console.log(a.riepilogo());
incassoMensile += a.prezzoMensile();
}
console.log(`Incasso del mese: ${incassoMensile} €`);
// Ada: 35 € al mese, 420 € all'anno
// Linus: 25 € al mese, 300 € all'anno
// Grace: 51 € al mese, 612 € all'anno
// Incasso del mese: 111 €
Pezzo per pezzo:
| Pezzo | Cosa vuol dire |
|---|---|
abstract class Abbonamento |
La classe è astratta: non si possono creare istanze con new Abbonamento(...) |
abstract prezzoMensile(): number; |
Un metodo astratto: ha nome, parametri e tipo di ritorno, ma niente corpo. Finisce con il ; |
costoAnnuale() e riepilogo() |
Metodi normali, con il corpo, che le figlie ereditano |
prezzoMensile() nelle figlie |
Il corpo che mancava. Ogni figlia scrive il suo |
Per il resto una classe astratta è una classe come le altre: ha proprietà, un costruttore, metodi completi. Le manca solo qualche pezzo.
Guardate costoAnnuale: è scritto nella madre e chiama this.prezzoMensile(), che nella madre non ha un corpo. Funziona perché this sarà sempre un'istanza di una figlia, e la figlia il corpo ce l'ha. È il polimorfismo della sezione 2 usato dalla madre stessa. La madre scrive la parte comune una volta e lascia alle figlie solo il pezzo che cambia.
Niente new sulla classe astratta
abstract class Abbonamento {
readonly intestatario: string;
constructor(intestatario: string) {
this.intestatario = intestatario;
}
abstract prezzoMensile(): number;
}
const a = new Abbonamento("Ada"); // errore: Cannot create an instance of an abstract class.
const b: Abbonamento[] = []; // va bene: il tipo si può usare
Il nome della classe astratta si usa come tipo, per variabili, parametri e array. Quello che non si può fare è crearne un'istanza.
La figlia deve implementare i metodi astratti
Se una figlia dimentica un metodo astratto, il compilatore si ferma:
abstract class Abbonamento {
readonly intestatario: string;
constructor(intestatario: string) {
this.intestatario = intestatario;
}
abstract prezzoMensile(): number;
}
class AbbonamentoWeekend extends Abbonamento { // errore: Non-abstract class 'AbbonamentoWeekend' does not implement inherited abstract member prezzoMensile from class 'Abbonamento'.
giorni(): string {
return "sabato e domenica";
}
}
Con una madre normale e un prezzo inventato, l'abbonamento weekend avrebbe ereditato quel prezzo senza che nessuno se ne accorgesse. Con il metodo astratto, chi scrive una figlia nuova non può dimenticarsi di decidere il prezzo.
Altri due messaggi che potreste incontrare:
abstract class Abbonamento {
abstract prezzoMensile(): number { // errore: Method 'prezzoMensile' cannot have an implementation because it is marked abstract.
return 35;
}
}
class Tessera {
abstract numero(): number; // errore: Abstract methods can only appear within an abstract class.
}
Il primo: un metodo astratto non ha corpo, per definizione. Il secondo: un metodo astratto può stare solo in una classe astratta, perché una classe normale deve poter creare istanze complete.
Anche Contenuto poteva essere astratta: nel catalogo non c'è mai "un contenuto" generico, ci sono film, episodi, documentari. Se scrivete abstract class Contenuto, nessuno potrà più fare new Contenuto(...) per sbaglio. Quando una madre esiste solo per raccogliere la parte comune delle figlie, di solito conviene farla astratta.
11-polimorfismo-e-classi-astratte.ipynb4. Interfacce
Classi diverse che sanno fare la stessa cosa
In casa avete un telefono, un monopattino elettrico e un paio di cuffie senza fili. Hanno poco in comune: un telefono non è un monopattino, e le cuffie non sono né l'uno né l'altro. Il test "è un" della sezione 1 fallisce per tutte le coppie, quindi una madre comune non ha senso.
Una cosa però la sanno fare tutti e tre: si ricaricano, e hanno un livello di batteria. Una app che vi avvisa di cosa mettere in carica stasera vuole trattarli tutti allo stesso modo, senza sapere cosa sono.
Un'interfaccia descrive proprio questo: cosa deve saper fare un oggetto, senza dire come lo fa e senza dire cosa è.
interface: il contratto
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
Un'interfaccia elenca proprietà e metodi, con i loro tipi, e niente altro. I metodi non hanno corpo, come i metodi astratti. Non c'è costruttore, non ci sono valori.
È un contratto: chi dice di essere Ricaricabile promette di avere un nome di tipo string, un metodo livelloBatteria() che restituisce un number e un metodo ricarica(). Il compilatore controlla che la promessa sia mantenuta.
implements
Una classe firma il contratto con implements:
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
class Telefono implements Ricaricabile {
nome: string;
private percentuale: number;
constructor(nome: string, percentuale: number) {
this.nome = nome;
this.percentuale = percentuale;
}
livelloBatteria(): number {
return this.percentuale;
}
ricarica(): void {
this.percentuale = 100;
}
chiama(numero: string): void {
console.log(`Chiamo ${numero}...`);
this.percentuale -= 1;
}
}
class Monopattino implements Ricaricabile {
nome: string;
private kmRimasti: number;
private readonly kmMassimi: number = 30;
constructor(nome: string, kmRimasti: number) {
this.nome = nome;
this.kmRimasti = kmRimasti;
}
livelloBatteria(): number {
return Math.round((this.kmRimasti / this.kmMassimi) * 100);
}
ricarica(): void {
this.kmRimasti = this.kmMassimi;
}
}
const telefono = new Telefono("Telefono di Ada", 64);
const monopattino = new Monopattino("Monopattino", 6);
telefono.chiama("333 1234567"); // Chiamo 333 1234567...
console.log(telefono.livelloBatteria()); // 63
console.log(monopattino.livelloBatteria()); // 20
Ogni classe fa a modo suo. Il telefono tiene una percentuale, il monopattino tiene i chilometri che può ancora fare e calcola la percentuale quando gliela chiedete. All'interfaccia non interessa: chiede solo che livelloBatteria() ci sia e restituisca un numero.
Una classe che implementa un'interfaccia può avere tutto quello che vuole in più: proprietà private, metodi suoi come chiama. Il contratto fissa il minimo, non il massimo.
Errore se il contratto non è rispettato
Le cuffie dimenticano ricarica:
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
class Cuffie implements Ricaricabile { // errore: Class 'Cuffie' incorrectly implements interface 'Ricaricabile'. Property 'ricarica' is missing in type 'Cuffie' but required in type 'Ricaricabile'.
nome: string = "Cuffie";
private percentuale: number = 80;
livelloBatteria(): number {
return this.percentuale;
}
}
Se invece il metodo c'è ma restituisce il tipo sbagliato, per esempio livelloBatteria(): string, l'errore è lo stesso dell'override sbagliato: Property 'livelloBatteria' in type 'Cuffie' is not assignable to the same property in base type 'Ricaricabile'. Il contratto promette un numero, la classe restituisce una stringa.
Parametri tipizzati con un'interfaccia
Il nome di un'interfaccia si usa come tipo, come il nome di una classe. Una funzione che riceve un Ricaricabile accetta qualsiasi oggetto che rispetti il contratto, e può usare solo quello che il contratto promette:
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
class Telefono implements Ricaricabile {
nome: string;
private percentuale: number;
constructor(nome: string, percentuale: number) {
this.nome = nome;
this.percentuale = percentuale;
}
livelloBatteria(): number {
return this.percentuale;
}
ricarica(): void {
this.percentuale = 100;
}
chiama(numero: string): void {
console.log(`Chiamo ${numero}...`);
}
}
function avvisaSeScarico(dispositivo: Ricaricabile): void {
const livello: number = dispositivo.livelloBatteria();
if (livello < 20) {
console.log(`${dispositivo.nome}: ${livello}%, mettilo in carica`);
}
// dispositivo.chiama("333 1234567"); errore: Property 'chiama' does not exist on type 'Ricaricabile'.
}
avvisaSeScarico(new Telefono("Telefono di Ada", 12)); // Telefono di Ada: 12%, mettilo in carica
avvisaSeScarico("telefono"); // errore: Argument of type 'string' is not assignable to parameter of type 'Ricaricabile'.
avvisaSeScarico non sa che cosa riceve. Sa solo che è ricaricabile, e le basta.
Polimorfismo con le interfacce
Il polimorfismo della sezione 2 funziona anche con le interfacce. Un Ricaricabile[] tiene oggetti di classi che non hanno niente in comune, e il ciclo li tratta tutti allo stesso modo:
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
class Telefono implements Ricaricabile {
nome: string;
private percentuale: number;
constructor(nome: string, percentuale: number) {
this.nome = nome;
this.percentuale = percentuale;
}
livelloBatteria(): number {
return this.percentuale;
}
ricarica(): void {
this.percentuale = 100;
}
}
class Monopattino implements Ricaricabile {
nome: string;
private kmRimasti: number;
private readonly kmMassimi: number = 30;
constructor(nome: string, kmRimasti: number) {
this.nome = nome;
this.kmRimasti = kmRimasti;
}
livelloBatteria(): number {
return Math.round((this.kmRimasti / this.kmMassimi) * 100);
}
ricarica(): void {
this.kmRimasti = this.kmMassimi;
}
}
class Cuffie implements Ricaricabile {
nome: string;
private oreRimaste: number;
constructor(nome: string, oreRimaste: number) {
this.nome = nome;
this.oreRimaste = oreRimaste;
}
livelloBatteria(): number {
return Math.round((this.oreRimaste / 20) * 100);
}
ricarica(): void {
this.oreRimaste = 20;
}
}
const dispositivi: Ricaricabile[] = [
new Telefono("Telefono", 64),
new Monopattino("Monopattino", 3),
new Cuffie("Cuffie", 2),
];
for (const d of dispositivi) {
if (d.livelloBatteria() < 20) {
console.log(`In carica: ${d.nome} (${d.livelloBatteria()}%)`);
d.ricarica();
}
}
// In carica: Monopattino (10%)
// In carica: Cuffie (10%)
Uno spazzolino elettrico è una classe in più, class Spazzolino implements Ricaricabile, e un elemento in più nell'array. Il ciclo non cambia.
Più interfacce
Una classe può estendere una sola madre, ma può implementare quante interfacce vuole. Basta separarle con la virgola. Il telefono e il monopattino si possono anche localizzare, le cuffie no:
interface Ricaricabile {
nome: string;
livelloBatteria(): number;
ricarica(): void;
}
interface Localizzabile {
posizione(): string;
}
class Telefono implements Ricaricabile, Localizzabile {
nome: string;
private percentuale: number = 50;
constructor(nome: string) {
this.nome = nome;
}
livelloBatteria(): number {
return this.percentuale;
}
ricarica(): void {
this.percentuale = 100;
}
posizione(): string {
return "Via Roma 12";
}
}
class Cuffie implements Ricaricabile {
nome: string = "Cuffie";
private percentuale: number = 80;
livelloBatteria(): number {
return this.percentuale;
}
ricarica(): void {
this.percentuale = 100;
}
}
function doveSiTrova(oggetto: Localizzabile): void {
console.log(`Si trova in ${oggetto.posizione()}`);
}
const telefono = new Telefono("Telefono di Ada");
doveSiTrova(telefono); // Si trova in Via Roma 12
doveSiTrova(new Cuffie()); // errore: Argument of type 'Cuffie' is not assignable to parameter of type 'Localizzabile'.
Il telefono è sia un Ricaricabile sia un Localizzabile: si può passare a avvisaSeScarico e a doveSiTrova. Ogni funzione chiede solo il contratto che le serve.
Una classe può anche estendere una madre e implementare interfacce insieme: class Telefono extends Dispositivo implements Ricaricabile, Localizzabile. Prima extends, poi implements.
Per TypeScript un oggetto rispetta un'interfaccia se ha le proprietà e i metodi giusti, anche se non ha scritto implements. Un'istanza di una classe Lampada che ha nome, livelloBatteria() e ricarica() si può passare ad avvisaSeScarico anche se Lampada non dichiara niente. implements resta utile: fa controllare il contratto già nella classe, dove l'errore si trova subito, invece che nel punto in cui la usate.
Un'interfaccia esiste solo per il compilatore. Nel JavaScript prodotto da tsc non ne resta traccia, quindi if (d instanceof Ricaricabile) è un errore: non c'è niente da controllare mentre il programma gira. I dettagli in Come lavora il compilatore con le classi.
12-interfacce.ipynb5. Quando usare cosa
Avete quattro modi di descrivere la forma di una cosa, e si somigliano.
| Cosa contiene | Si fa new? |
Quando sceglierlo | |
|---|---|---|---|
class |
Proprietà con i valori, costruttore, metodi con il corpo | Sì | Una cosa con dei dati e delle operazioni su quei dati: un contapassi, un salvadanaio |
abstract class |
Come una classe, con alcuni metodi senza corpo | No, solo le figlie | Una famiglia di classi dove la frase "è un" è vera, con molto codice in comune e un pezzo che cambia: gli abbonamenti |
interface |
Nomi e tipi di proprietà e metodi, niente codice | No | Classi diverse, senza una madre comune, che devono saper fare la stessa cosa: i dispositivi ricaricabili |
type |
Nomi e tipi, niente codice | No | Dati semplici senza metodi (type Evento = { titolo: string; ora: number }) e le unioni (type Taglia = "S" \| "M" \| "L") |
interface e type si somigliano molto quando descrivono un oggetto, e in parte sono intercambiabili. Nel corso usiamo type per i dati semplici e interface per i contratti che le classi firmano con implements.
L'ereditarietà, con moderazione
L'ereditarietà è comoda, e se ne abusa facilmente. Tre problemi:
- Una madre sola. Se una classe estende
Contenuto, non può estendere nient'altro. Le interfacce non hanno questo limite. - Le figlie dipendono dalla madre. Ogni modifica alla madre arriva a tutte le figlie, anche a quelle che non conoscete. Se cambiate
descrivi()inContenuto, cambia la descrizione dei documentari, e di ogni figlia che non lo ridefinisce. - Le gerarchie crescono male. Oggi
FilmestendeContenuto. Domani servono i film in 4K, i film per bambini, i film per bambini in 4K... e ogni combinazione diventa una classe. L'approfondimento Composizione o ereditarietà mostra un esempio completo.
Per questo nei libri e nei progetti troverete spesso il consiglio "preferire la composizione all'ereditarietà". Comporre vuol dire costruire una classe mettendoci dentro altri oggetti, come proprietà, invece di estendere una madre. È la risposta "ha un" del test della sezione 1.
Un esempio di composizione
Il telefono e il monopattino della sezione 4 hanno tutti e due una batteria, con la stessa logica: si scarica, si ricarica, ha una percentuale. Per non scrivere quella logica due volte, viene da pensare all'ereditarietà:
class Batteria {
private carica: number;
constructor(carica: number) {
this.carica = carica;
}
percentuale(): number {
return this.carica;
}
consuma(quanto: number): void {
this.carica = Math.max(this.carica - quanto, 0);
}
ricarica(): void {
this.carica = 100;
}
}
// Sbagliato: un telefono non è una batteria
class Telefono extends Batteria {
chiama(numero: string): void {
console.log(`Chiamo ${numero}...`);
this.consuma(1);
}
}
const telefono = new Telefono(50);
telefono.consuma(40); // compila: chiunque può scaricare il telefono da fuori
Il test "è un" fallisce: "un telefono è una batteria" è falso. E infatti si vede subito un effetto strano: consuma è un metodo pubblico della batteria, quindi adesso è anche un metodo pubblico del telefono. Chiunque può scrivere telefono.consuma(40), che per un telefono non vuol dire niente.
La frase giusta è "un telefono ha una batteria". Allora la batteria diventa una proprietà:
// Batteria come nel blocco sopra
class Telefono {
private batteria: Batteria;
constructor(caricaIniziale: number) {
this.batteria = new Batteria(caricaIniziale);
}
chiama(numero: string): void {
console.log(`Chiamo ${numero}...`);
this.batteria.consuma(1);
}
livelloBatteria(): number {
return this.batteria.percentuale();
}
ricarica(): void {
this.batteria.ricarica();
}
}
class Monopattino {
private batteria: Batteria;
constructor(caricaIniziale: number) {
this.batteria = new Batteria(caricaIniziale);
}
percorri(km: number): void {
this.batteria.consuma(km * 3);
}
livelloBatteria(): number {
return this.batteria.percentuale();
}
}
const telefono = new Telefono(50);
telefono.chiama("333 1234567"); // Chiamo 333 1234567...
console.log(telefono.livelloBatteria()); // 49
const monopattino = new Monopattino(80);
monopattino.percorri(10);
console.log(monopattino.livelloBatteria()); // 50
La logica della batteria è scritta una volta sola, in Batteria, e la usano tutti e due. Il telefono decide cosa mostrare all'esterno: livelloBatteria e ricarica sì, consuma no. Il monopattino fa le sue scelte, diverse. E nessuno dei due ha speso il suo unico extends: se domani il telefono deve estendere un'altra classe, può farlo.
Per decidere:
| La frase giusta è... | Usate |
|---|---|
| "X è un Y", e lo è sempre, in ogni situazione | extends (spesso con una madre astratta) |
| "X ha un Y" | Una proprietà di tipo Y: composizione |
| "X sa fare questa cosa", come altre classi diverse da lui | implements di un'interfaccia |
Nel dubbio, partite dalla composizione. Passare da composizione a ereditarietà più avanti è facile, il contrario molto meno.
12-interfacce.ipynb, gli ultimi esercizi6. Riepilogo
class Figlia extends Madredà alla figlia tutte le proprietà e i metodi della madre. Il costruttore della figlia chiamasuper(...)prima di usarethis;protectedapre una proprietà alle figlie e la tiene chiusa al resto del programma.- Una figlia può aggiungere metodi suoi e ridefinire quelli della madre (override). Con
super.metodo()richiama la versione della madre. In memoria un'istanza della figlia è un solo spazio, con le proprietà di tutte e due le classi. - Prima di
extends, il test "è un": se la frase giusta è "ha un", serve una proprietà, non una madre. - Polimorfismo: una variabile del tipo madre può contenere un'istanza della figlia. Il tipo della variabile decide cosa potete chiamare, l'istanza decide quale versione parte, mentre il programma gira. Così un ciclo tratta oggetti diversi allo stesso modo, e un tipo nuovo si aggiunge senza toccare il ciclo.
- Una classe astratta non crea istanze e può lasciare metodi astratti, senza corpo, che ogni figlia deve scrivere. Il compilatore controlla tutte e due le regole.
- Un'interfaccia è un contratto: nomi e tipi, niente codice. Una classe lo firma con
implements, e può firmarne più di uno. Funzioni e array tipizzati con un'interfaccia accettano qualsiasi oggetto che rispetti il contratto. - Usate l'ereditarietà con moderazione: nel dubbio, comporre (una classe che contiene altri oggetti) è più flessibile che estendere.
Classi, interfacce e composizione sono gli attrezzi di base della programmazione a oggetti. Nel corso di Design Pattern vedrete i modi classici di combinarli per problemi che si ripresentano sempre uguali.