Les classes en TypeScript

Cet article explique les classes en TypeScript.

YouTube Video

Les classes en TypeScript

Les classes en TypeScript sont basées sur les classes ES6 de JavaScript et offrent des fonctionnalités supplémentaires telles que les annotations de type et les modificateurs d'accès. Cela vous permet de tirer parti des concepts de la programmation orientée objet tout en garantissant une sécurité des types plus robuste et claire.

Voici des explications sur l'utilisation de base et les fonctionnalités des classes en TypeScript.

Définition de base d'une 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 et age sont des propriétés (variables membres) de la classe.
• Le constructor est une méthode appelée lors de la création d'une instance d'une classe, qui prend des arguments et attribue des valeurs aux propriétés.
• greet est une méthode de la classe, indiquant qu'elle n'a pas de valeur de retour en étant de type void.

Modificateurs d'accès

En TypeScript, vous pouvez utiliser des modificateurs d'accès (public, private, protected) pour contrôler l'accès aux propriétés et méthodes d'une classe.

public

Par défaut, toutes les propriétés et méthodes sont public. Cela signifie qu'elles peuvent être accessibles depuis l'extérieur de la 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 propriété species et la méthode makeSound sont déclarées comme public et peuvent être accessibles depuis l'extérieur de la classe.

private

L'utilisation du modificateur private empêche l'accès aux propriétés ou méthodes depuis l'extérieur de la 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 propriété brand est déclarée comme private, donc elle ne peut pas être accessible depuis l'extérieur de la classe.
• L'encapsulation des données peut être réalisée en cachant des propriétés avec le modificateur private.

protected

Le modificateur protected restreint l'accès depuis l'extérieur de la classe mais le permet dans les sous-classes (classes dérivées).

 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 propriété model est déclarée comme protected, donc elle ne peut pas être accessible depuis l'extérieur de la classe, mais elle peut l'être depuis les sous-classes.

Accesseurs et mutateurs (Getters et Setters)

En TypeScript, vous pouvez définir des accesseurs et des mutateurs à l'aide des mots-clés get et set pour récupérer et définir des valeurs de propriété.

 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.

• Dans cet exemple, un getter et un setter sont utilisés pour la propriété salary afin de contrôler l'accès extérieur et les mises à jour. Le setter effectue une validation pour empêcher les valeurs négatives et affiche un message d'avertissement si une valeur invalide est fournie.

Héritage

En TypeScript, les classes peuvent être héritées. En utilisant le mot-clé extends, vous pouvez hériter des fonctionnalités d'une classe parente.

 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.

• Dans cet exemple, la classe Bird hérite de la classe Animal, ce qui lui permet d'utiliser la méthode move d'Animal. De plus, elle définit sa propre méthode fly, ajoutant de nouvelles fonctionnalités tout en héritant des caractéristiques de la classe parente.

Classes abstraites

Les classes abstraites (abstract) ne peuvent pas être instanciées directement et sont utilisées comme modèles pour fournir des implémentations concrètes dans les sous-classes.

 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.

• Dans cet exemple, Shape est définie comme une classe abstraite et getArea est une méthode abstraite qui doit être implémentée par les sous-classes. La classe Circle hérite de cette classe abstraite et implémente sa propre méthode getArea pour calculer l'aire d'un cercle. De plus, des méthodes concrètes comme describe sont héritées en tant que fonctionnalités communes et peuvent être utilisées telles quelles.

Relation avec les interfaces

Les classes peuvent implémenter des interfaces, garantissant qu'elles possèdent des propriétés et méthodes spécifiques.

 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.

• Dans cet exemple, l'interface Flyable définit la spécification pour la méthode fly, et la classe Airplane implémente cette interface en fournissant une définition concrète de la méthode fly. Ainsi, tout objet pouvant être considéré comme de type Flyable est garanti de posséder une méthode fly.

Membres statiques

Lorsque vous définissez des membres statiques dans une classe, ces méthodes et propriétés sont associées à la classe elle-même. Les membres statiques peuvent être appelés sans instancier 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

• Vous définissez des méthodes statiques en utilisant le mot-clé static.
• Dans cet exemple, la classe MathUtils définit une méthode statique add et une propriété statique PI.
• Les membres statiques n'appartiennent pas aux instances de la classe, mais peuvent être appelés directement depuis la classe elle-même.

Résumé

Les classes TypeScript ajoutent des fonctionnalités telles que la sécurité des types, les modificateurs d'accès et les classes abstraites à la fonctionnalité des classes JavaScript. Cela permet une programmation orientée objet plus puissante et plus sécurisée.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video