TypeScript - Eredità

Ciao, futuri programmatori! Oggi ci imbarcheremo in un viaggio entusiasmante nel mondo dell'eredità di TypeScript. Come il vostro amico insegnante di informatica del quartiere, sono qui per guidarvi attraverso questo affascinante argomento. Allora, prendete i vostri zaini virtuali e tuffiamoci!

Cos'è l'Eredità?

Prima di iniziare, cerchiamo di capire cosa significa davvero l'eredità. Immagina di creare un albero genealogico. Ogni nuova generazione eredita determinate caratteristiche dai propri genitori. Nel programming, l'eredità funziona allo stesso modo. Permette a una nuova classe di essere basata su una classe esistente, ereditandone le proprietà e i metodi. Bello, vero?

Eredità Singola

Iniziamo con la forma più semplice di eredità: l'eredità singola. Questo è quando una classe (classe figlia) eredita da un'altra classe (classe padre).

Esempio di Base

class Animal {
name: string;

constructor(name: string) {
this.name = name;
}

makeSound(): void {
console.log("Some generic animal sound");
}
}

class Dog extends Animal {
breed: string;

constructor(name: string, breed: string) {
super(name);
this.breed = breed;
}

makeSound(): void {
console.log("Woof! Woof!");
}
}

let myDog = new Dog("Buddy", "Golden Retriever");
console.log(myDog.name);  // Output: Buddy
console.log(myDog.breed); // Output: Golden Retriever
myDog.makeSound();        // Output: Woof! Woof!

In questo esempio, Dog eredita da Animal. La parola chiave extends viene utilizzata per creare una classe che è figlia di un'altra classe.

Spiegazione

1. Definiamo una classe base Animal con una proprietà name e un metodo makeSound.
2. Poi creiamo una classe Dog che estende Animal.
3. La classe Dog ha la sua proprietà breed.
4. Utilizziamo la parola chiave super nel costruttore di Dog per chiamare il costruttore di Animal.
5. Sovrascriviamo il metodo makeSound nella classe Dog.

Parola Chiave Super

Potreste aver notato la parola chiave super nel nostro esempio precedente. Esploriamo più a fondo cosa fa.

Esempio con Super

class Vehicle {
make: string;
model: string;

constructor(make: string, model: string) {
this.make = make;
this.model = model;
}

getInfo(): string {
return `${this.make} ${this.model}`;
}
}

class Car extends Vehicle {
numDoors: number;

constructor(make: string, model: string, numDoors: number) {
super(make, model);
this.numDoors = numDoors;
}

getInfo(): string {
return `${super.getInfo()} with ${this.numDoors} doors`;
}
}

let myCar = new Car("Toyota", "Corolla", 4);
console.log(myCar.getInfo()); // Output: Toyota Corolla with 4 doors

Spiegazione

1. La parola chiave super viene utilizzata nel costruttore di Car per chiamare il costruttore di Vehicle.
2. Nel metodo getInfo della classe Car, utilizziamo super.getInfo() per chiamare il metodo getInfo della classe padre.

La parola chiave super ci permette di accedere e chiamare funzioni su un oggetto del padre.

Sovrascrittura del Metodo

La sovrascrittura del metodo si verifica quando una classe figlia fornisce una implementazione specifica di un metodo già definito nella sua classe padre. Abbiamo visto questo nei nostri esempi precedenti!

Un Altro Esempio di Sovrascrittura del Metodo

class Shape {
getArea(): number {
return 0;
}
}

class Circle extends Shape {
radius: number;

constructor(radius: number) {
super();
this.radius = radius;
}

getArea(): number {
return Math.PI * this.radius * this.radius;
}
}

class Rectangle extends Shape {
width: number;
height: number;

constructor(width: number, height: number) {
super();
this.width = width;
this.height = height;
}

getArea(): number {
return this.width * this.height;
}
}

let myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: 78.53981633974483

let myRectangle = new Rectangle(4, 5);
console.log(myRectangle.getArea()); // Output: 20

Spiegazione

1. Abbiamo una classe base Shape con un metodo getArea che restituisce 0.
2. Entrambe le classi Circle e Rectangle estendono Shape e sovrascrivono il metodo getArea con le loro proprie implementazioni.
3. La classe Circle calcola l'area utilizzando la formula πr².
4. La classe Rectangle calcola l'area moltiplicando larghezza e altezza.

Eredità Multilivello

L'eredità multilivello coinvolge una classe figlia che eredita da un'altra classe figlia. È come un albero genealogico con più generazioni.

Esempio di Eredità Multilivello

class Grandparent {
surname: string;

constructor(surname: string) {
this.surname = surname;
}

getSurname(): string {
return this.surname;
}
}

class Parent extends Grandparent {
firstName: string;

constructor(firstName: string, surname: string) {
super(surname);
this.firstName = firstName;
}

getFullName(): string {
return `${this.firstName} ${this.getSurname()}`;
}
}

class Child extends Parent {
middleName: string;

constructor(firstName: string, middleName: string, surname: string) {
super(firstName, surname);
this.middleName = middleName;
}

getFullName(): string {
return `${this.firstName} ${this.middleName} ${this.getSurname()}`;
}
}

let myChild = new Child("John", "Doe", "Smith");
console.log(myChild.getFullName()); // Output: John Doe Smith

Spiegazione

1. Abbiamo una classe Grandparent con una proprietà surname.
2. La classe Parent estende Grandparent e aggiunge una proprietà firstName.
3. La classe Child estende Parent e aggiunge una proprietà middleName.
4. Ogni classe ha la sua implementazione del metodo getFullName.

Riepilogo dei Metodi di Eredità

Ecco una tabella che riepiloga i metodi e le parole chiave chiave che abbiamo discusso:

Metodo/Parola Chiave	Descrizione
extends	Utilizzato per creare una classe come figlia di un'altra classe
super()	Chiama il costruttore della classe padre
super.method()	Chiama un metodo dalla classe padre
Sovrascrittura del Metodo	Fornire una nuova implementazione per un metodo in una classe figlia

Eccoci! Abbiamo coperto le basi dell'eredità in TypeScript. Ricorda, la pratica rende perfetti, quindi non esitare a sperimentare con questi concetti. Buon codice, futuri maghi di TypeScript!

Credits: Image by storyset