Classi in TypeScript

Questo articolo spiega le classi in TypeScript.

YouTube Video

Classi in TypeScript

Le classi in TypeScript si basano sulle classi ES6 di JavaScript e offrono funzionalità aggiuntive come annotazioni di tipo e modificatori di accesso. Questo ti permette di sfruttare i concetti della programmazione orientata agli oggetti garantendo al contempo una sicurezza dei tipi più robusta e chiara.

Di seguito sono riportate le spiegazioni sull'uso di base e sulle funzionalità delle classi in TypeScript.

Definizione di Base della Classe

 1class Person {
 2    name: string;  // Member variable
 3    age: number;   // Member variable
 4
 5    // Constructor
 6    constructor(name: string, age: number) {
 7        this.name = name;
 8        this.age = age;
 9    }
10
11    // Method
12    greet(): void {
13        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
14    }
15}
16
17const person = new Person("Alice", 25);
18person.greet();  // Hello, my name is Alice and I am 25 years old.

• name e age sono proprietà (variabili membro) della classe.
• Il constructor è un metodo chiamato durante la creazione di un'istanza di una classe, che accetta argomenti e assegna valori alle proprietà.
• greet è un metodo della classe, che indica di non avere un valore restituito grazie al tipo void.

Modificatori di Accesso

In TypeScript, puoi utilizzare i modificatori di accesso (public, private, protected) per controllare l'accesso alle proprietà e ai metodi della classe.

public

Per impostazione predefinita, tutte le proprietà e i metodi sono public. Ciò significa che possono essere accessibili dall'esterno della classe.

 1class Animal {
 2    public species: string;
 3
 4    constructor(species: string) {
 5        this.species = species;
 6    }
 7
 8    public makeSound(): void {
 9        console.log(`${this.species} makes a sound.`);
10    }
11}
12
13const animal = new Animal("Dog");
14console.log(animal.species);  // Dog
15animal.makeSound();           // Dog makes a sound.

• La proprietà species e il metodo makeSound sono dichiarati come public e possono essere accessi dall'esterno della classe.

private

L'utilizzo del modificatore private impedisce l'accesso alle proprietà o ai metodi dall'esterno della classe.

 1class Car {
 2    private brand: string;
 3
 4    constructor(brand: string) {
 5        this.brand = brand;
 6    }
 7
 8    public getBrand(): string {
 9        return this.brand;
10    }
11}
12
13const car = new Car("Toyota");
14// console.log(car.brand);  // Error: 'brand' is private and cannot be accessed.
15console.log(car.getBrand());  // Toyota

• La proprietà brand è dichiarata come private, quindi non può essere accessa dall'esterno della classe.
• L'incapsulamento dei dati può essere ottenuto nascondendo le proprietà con il modificatore private.

protected

Il modificatore protected limita l'accesso dall'esterno della classe ma lo consente nelle sottoclassi (classi derivate).

 1class Vehicle {
 2    protected model: string;
 3
 4    constructor(model: string) {
 5        this.model = model;
 6    }
 7}
 8
 9class Truck extends Vehicle {
10    public getModel(): string {
11        return this.model;
12    }
13}
14
15const truck = new Truck("Ford F-150");
16console.log(truck.getModel());  // Ford F-150
17
18// console.log(truck.model);
19// Error: Property 'model' is protected and only accessible within class 'Vehicle' and its subclasses.

• La proprietà model è dichiarata come protected, quindi non può essere accessa dall'esterno della classe, ma può essere accessa dalle sottoclassi.

Getter e Setter

In TypeScript, puoi definire getter e setter utilizzando le parole chiave get e set per recuperare e impostare i valori delle proprietà.

 1class Employee {
 2    private _salary: number;
 3
 4    constructor(salary: number) {
 5        this._salary = salary;
 6    }
 7
 8    // Getter
 9    get salary(): number {
10        return this._salary;
11    }
12
13    // Setter
14    set salary(newSalary: number) {
15        if (newSalary > 0) {
16            this._salary = newSalary;
17        } else {
18            console.log("Salary must be positive.");
19        }
20    }
21}
22
23const employee = new Employee(50000);
24console.log(employee.salary);  // 50000
25employee.salary = 60000;
26console.log(employee.salary);  // 60000
27employee.salary = -100;        // Salary must be positive.

• In questo esempio, un getter e un setter vengono utilizzati per la proprietà salary per controllare l'accesso e gli aggiornamenti esterni. Il setter esegue una validazione per prevenire valori negativi e mostra un messaggio di avviso se viene fornito un valore non valido.

Ereditarietà

In TypeScript, le classi possono essere ereditate. Utilizzando la parola chiave extends, puoi ereditare funzionalità da una classe genitore.

 1class Animal {
 2    constructor(public name: string) {}
 3
 4    public move(): void {
 5        console.log(`${this.name} is moving.`);
 6    }
 7}
 8
 9class Bird extends Animal {
10    public fly(): void {
11        console.log(`${this.name} is flying.`);
12    }
13}
14
15const bird = new Bird("Sparrow");
16bird.move();  // Sparrow is moving.
17bird.fly();   // Sparrow is flying.

• In questo esempio, la classe Bird eredita dalla classe Animal, il che le consente di utilizzare il metodo move di Animal. Inoltre, definisce il proprio metodo fly, aggiungendo nuove funzionalità pur ereditando le caratteristiche dalla classe madre.

Classi Astratte

Le classi astratte (abstract) non possono essere istanziate direttamente e vengono utilizzate come modelli per fornire implementazioni concrete nelle sottoclassi.

 1abstract class Shape {
 2    abstract getArea(): number;
 3
 4    public describe(): void {
 5        console.log("This is a shape.");
 6    }
 7}
 8
 9class Circle extends Shape {
10    constructor(private radius: number) {
11        super();
12    }
13
14    public getArea(): number {
15        return Math.PI * this.radius * this.radius;
16    }
17}
18
19const circle = new Circle(5);
20console.log(circle.getArea());  // 78.53981633974483
21circle.describe();  // This is a shape.

• In questo esempio, Shape è definita come una classe astratta, e getArea è un metodo astratto che deve essere implementato dalle sottoclassi. La classe Circle eredita questa classe astratta e implementa il proprio metodo getArea per calcolare l'area di un cerchio. Inoltre, i metodi concreti come describe sono ereditati come funzionalità comuni e possono essere utilizzati così come sono.

Relazione con le Interfacce

Le classi possono implementare interfacce, garantendo che dispongano di proprietà e metodi specifici.

 1interface Flyable {
 2    fly(): void;
 3}
 4
 5class Airplane implements Flyable {
 6    public fly(): void {
 7        console.log("The airplane is flying.");
 8    }
 9}
10
11const airplane: Flyable = new Airplane();
12airplane.fly();  // The airplane is flying.

• In questo esempio, l'interfaccia Flyable definisce la specifica per il metodo fly e la classe Airplane implementa questa interfaccia fornendo una definizione concreta per il metodo fly. In questo modo, qualsiasi oggetto che può essere trattato come un tipo Flyable è garantito di avere un metodo fly.

Membri Statici

Quando definisci membri statici in una classe, quei metodi e proprietà sono associati direttamente alla classe stessa. I membri statici possono essere chiamati senza istanziare la classe.

 1class MathUtils {
 2    static PI: number = 3.14;
 3
 4    static add(a: number, b: number): number {
 5        return a + b;
 6    }
 7}
 8
 9console.log(MathUtils.add(10, 20)); // 30
10console.log(MathUtils.PI); // 3.14

• I metodi statici si definiscono usando la parola chiave static.
• In questo esempio, la classe MathUtils definisce un metodo statico add e una proprietà statica PI.
• I membri statici non appartengono alle istanze della classe, ma possono essere chiamati direttamente dalla classe stessa.

Riepilogo

Le classi di TypeScript aggiungono funzionalità come sicurezza dei tipi, modificatori di accesso e classi astratte alla funzionalità delle classi JavaScript. Questo consente una programmazione orientata agli oggetti più potente e sicura.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video