Lavorare con classi e interfacce in TypeScript
Scopri come utilizzare l'ereditarietà in TypeScript per creare classi più organizzate e facili da manutenere. Impara a utilizzare la parola chiave "extends" per creare una classe che estende le caratteristiche di un'altra classe, ereditando le sue proprietà e metodi.
Le classi e le interfacce sono fondamentali per la programmazione orientata agli oggetti e TypeScript le supporta pienamente. Le classi consentono di creare oggetti con proprietà e metodi, mentre le interfacce consentono di definire un contratto per le proprietà e i metodi che un oggetto o classe deve avere.
Per creare una classe in TypeScript, si utilizza la seguente sintassi:
class NomeClasse {
// proprietà e metodi
}
Per esempio, per creare una classe chiamata Automobile con proprietà come marca e modello, si utilizzerebbe la seguente sintassi:
class Automobile {
marca: string;
modello: string;
}
Per creare un'istanza di questa classe e assegnare valori alle proprietà, si utilizzerebbe la seguente sintassi:
let automobile: Automobile = new Automobile();
automobile.marca = "Tesla";
automobile.modello = "Model S";
Inoltre, le classi possono anche avere metodi. ad esempio, si può creare un metodo chiamato accelera() per la classe Automobile:
class Automobile {
marca: string;
modello: string;
accelera() {
console.log("La macchina accelera.");
}
}
e possiamo chiamarlo cosi
let automobile: Automobile = new Automobile();
automobile.accelera();
Le interfacce, d'altra parte, consentono di definire un contratto per le proprietà e i metodi che una classe deve avere, senza definire la loro implementazione. Ad esempio, si può creare un'interfaccia chiamata Veicolo con proprietà come numeroRuote e velocitàMassima:
interface Veicolo {
numeroRuote: number;
velocitàMassima: number;
}
La classe Automobile può quindi implementare l'interfaccia Veicolo:
class Automobile implements Veicolo {
marca: string;
modello: string;
numeroRuote: number = 4;
velocitàMassima: number;
accelera() {
console.log("La macchina accelera.");
}
}
In questo modo, le interfacce consentono di garantire che le classi che le implementano abbiano determinate proprietà e metodi, assicurando che siano compatibili con un determinato contratto. Inoltre, le interfacce possono anche essere estese da altre interfacce, in modo da poter estendere il contratto in modo efficace.
Inoltre, è possibile utilizzare la notazione della classe per creare classi più concise e leggibili. Ad esempio, si può creare la classe Automobile utilizzando la notazione della classe:
class Automobile {
constructor(public marca: string, public modello: string) {}
accelera() {
console.log("La macchina accelera.");
}
}
In questa notazione, le proprietà vengono passate al costruttore della classe e vengono dichiarate come proprietà pubbliche all'interno della classe stessa. Ciò consente di creare una classe più breve e più leggibile, senza dover dichiarare esplicitamente le proprietà all'interno della classe.
In conclusione, le classi e le interfacce sono fondamentali per la programmazione orientata agli oggetti e TypeScript le supporta pienamente. Le classi consentono di creare oggetti con proprietà e metodi, mentre le interfacce consentono di definire un contratto per le proprietà e i metodi che un oggetto o classe deve avere. Inoltre, la notazione della classe offre una sintassi più concisa e leggibile per creare classi. Utilizzando queste funzionalità, è possibile creare codice più organizzato e facile da manutenere.
Ereditarietà
L'ereditarietà è uno dei concetti chiave della programmazione orientata agli oggetti e TypeScript lo supporta attraverso l'utilizzo di classi. Con l'ereditarietà, è possibile creare una classe che estende le caratteristiche di un'altra classe, ereditando le sue proprietà e metodi.
Per creare una classe che estende un'altra classe, si utilizza la parola chiave "extends" seguita dal nome della classe da estendere. Ad esempio, si può creare una classe chiamata "Camion" che estende la classe "Automobile":
class Camion extends Automobile {
capacitàCarico: number;
caricaMerce() {
console.log("La merce è stata caricata sul camion.");
}
}
In questo esempio, la classe Camion eredita tutte le proprietà e i metodi della classe Automobile, oltre ad avere la proprietà capacitàCarico e il metodo caricaMerce(). Ciò significa che un'istanza della classe Camion può chiamare i metodi accelera() della classe Automobile.
Inoltre, la classe estesa può anche scegliere di implementare delle modifiche o estendere i metodi ereditati. Per fare ciò, si utilizza la parola chiave super nell'override del metodo per chiamare il metodo della classe base e poi si effettuano le modifiche desiderate.
class Camion extends Automobile {
capacitàCarico: number;
caricaMerce() {
super.accelera();
console.log("La merce è stata caricata sul camion e adesso stiamo accelerando");
}
}
Inoltre, anche le interfacce possono essere ereditate, in questo caso utilizzando la parola chiave extends. In questo modo un'interfaccia può estendere un'altra interfaccia ereditando i suoi metodi e proprietà
interface TrasportoMerci extends Veicolo {
capacitàCarico: number;
caricaMerce(): void;
}
In conclusione, l'ereditarietà è un concetto fondamentale nella programmazione orientata agli oggetti e TypeScript lo supporta attraverso l'utilizzo di classi e interfacce. Con l'ereditarietà, è possibile creare classi che estendono le caratteristiche di un'altra classe, ereditando le sue proprietà e metodi. Ciò consente di creare codice più organizzato e facile da manutenere.
Comments ()