Introduction aux fonctionnalités avancées des classes

TypeScript propose plusieurs fonctionnalités avancées des classes qui vous aident à écrire du code orienté objet modulaire, évolutif et facile à maintenir.

Dans cette leçon, vous découvrirez les modificateurs d’accès, les classes abstraites, les membres statiques et bien plus encore.

Introduction aux fonctionnalités avancées des classes

TypeScript propose plusieurs fonctionnalités avancées des classes qui vous aident à écrire du code orienté objet modulaire, évolutif et facile à maintenir.

Dans cette leçon, vous découvrirez les modificateurs d’accès, les classes abstraites, les membres statiques et bien plus encore.

Modificateurs d’accès

TypeScript fournit trois modificateurs d’accès pour contrôler la visibilité des membres d’une classe :

• public : accessible partout (par défaut).
• private : accessible uniquement au sein de la classe.
• protected : accessible au sein de la classe et de ses sous-classes.

class Person {
  public name: string;
  private age: number;
  protected role: string;

  constructor(name: string, age: number, role: string) {
    this.name = name;
    this.age = age;
    this.role = role;
  }
}

class Employee extends Person {
  getRole(): string {
    return this.role; // Accessible because it's protected
  }
}

Classes abstraites

Les classes abstraites servent de modèles pour d’autres classes. Elles ne peuvent pas être instanciées directement et peuvent contenir des méthodes abstraites.

abstract class Shape {
  abstract getArea(): number;
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

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

const circle = new Circle(5);
console.log(circle.getArea()); // 78.54

Membres statiques

Les membres statiques appartiennent à la classe elle-même plutôt qu’à une instance de la classe. Ils sont accessibles à l’aide du nom de la classe.

class MathUtils {
  static PI = 3.14;

  static calculateCircleArea(radius: number): number {
    return this.PI * radius ** 2;
  }
}

console.log(MathUtils.PI); // 3.14
console.log(MathUtils.calculateCircleArea(5)); // 78.5

Accesseurs et mutateurs

Les accesseurs et les mutateurs vous permettent de contrôler la manière dont les propriétés sont consultées ou modifiées dans une classe.

class Person {
  private _name: string;

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

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    this._name = newName;
  }
}

const person = new Person('Alice');
console.log(person.name); // Alice
person.name = 'Bob';
console.log(person.name); // Bob

Propriétés en lecture seule

Le modificateur readonly garantit qu’une propriété ne peut être définie que lors de l’initialisation et ne peut plus être modifiée par la suite.

class Vehicle {
  readonly make: string;

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

const car = new Vehicle('Toyota');
console.log(car.make); // Toyota
// car.make = 'Honda'; // Error: Cannot assign to 'make' because it is a read-only property.

Constructeurs privés et protégés

Les classes peuvent avoir des constructeurs privés ou protégés afin de contrôler la manière dont elles sont instanciées et les endroits où cela est possible.

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  static getInstance(): Singleton {
    if (!this.instance) {
      this.instance = new Singleton();
    }
    return this.instance;
  }
}

const singleton = Singleton.getInstance();
console.log(singleton);

Exercice pratique

Créez une classe dotée d’un constructeur protected, puis étendez-la dans une sous-classe. Ajoutez des méthodes permettant d’accéder aux propriétés protégées dans la sous-classe.

Félicitations !

Vous avez appris des fonctionnalités avancées des classes, comme les modificateurs d’accès, les classes abstraites, les membres statiques et bien plus encore. Mettez ces concepts en pratique pour écrire du code TypeScript orienté objet propre et efficace !