TypeScript
12 - Classes

Les classes

Les classes sont natives en JS depuis ES6, et TypeScript les supporte également.

Une classe en TypeScript peut contenir des propriétés et des méthodes. La syntaxe de base ressemble beaucoup à celle d'autres langages orientés objet comme Java ou C#. Les classes supportent également des fonctionnalités avancées comme les constructeurs, l'encapsulation, l'héritage, et les polymorphismes.

3 éléments importants :

  • Heritage
  • Encapsulation
  • Polymorphisme
class Person {
    name: string;
    age: number;
 
    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
 
    describe(): string {
        return `My name is ${this.name} and I am ${this.age} years old.`;
    }
}
 
let person = new Person("Alice", 30);
console.log(person.describe());
  • Il faut utiliser le mot clé class suivi du nom de la classe. Les propriétés et méthodes sont déclarées à l'intérieur de la classe. Les méthodes peuvent être appelées sur une instance de la classe.
  • Le constructeur (constructor) est une méthode spéciale appelée lors de la création d'une instance de la classe. A chaque fois qu'un objet est créé, le constructeur est appelé pour initialiser ses propriétés.
  • this est une référence à l'instance actuelle de la classe. Il est utilisé pour accéder aux propriétés et méthodes de l'instance.
  • name et age sont des propriétés de la classe Person.
  • describe est une méthode de la classe Person.

Héritage

L'héritage permet à une classe de de récupérer les propriétés et méthodes d'une autre classe. Il faut utiliser le mot clé extends pour hériter d'une classe.

class Employee extends Person {
    department: string;
    company: string;
 
    constructor(name: string, age: number, department: string, company: string) {
        super(name, age); // Appel au constructeur de la classe parente
        this.department = department;
        this.company = company;
    }
 
    describe(): string {
        return `${super.describe()} I work in ${this.department}, ${company}.`;
    }
}
 
let employee = new Employee("Bob", 28, "Engineering", "ACME");
console.log(employee.describe());
  • super est utilisé pour appeler les méthodes de la classe parente. Dans le constructeur, super est utilisé pour appeler le constructeur de la classe parente.

Encapsulation

L'encapsulation est un principe fondamental de la POO (Programmation Orienté Objet) qui consiste à regrouper les données (variables) et les méthodes qui manipulent ces données dans une unité unique, tout en cachant certains détails internes du reste du programme.

class Account {
    private balance: number;
 
    constructor(initialBalance: number) {
        this.balance = initialBalance;
    }
 
    deposit(amount: number): void {
        this.balance += amount;
        console.log(`Deposited ${amount}, total balance now is: ${this.balance}`);
    }
 
    private calculateInterest(rate: number): number {
        return this.balance * rate;
    }
 
    addInterest(rate: number): void {
        let interest = this.calculateInterest(rate);
        this.deposit(interest);
    }
}

Polymorphisme

Le polymorphimse permet d'appliquer a une meme methode des comportements differents en fonction du type de l'objet.

class Shape {
    area(): number {
        return 0;
    }
}
 
class Circle extends Shape {
    radius: number;
 
    constructor(radius: number) {
        super();
        this.radius = radius;
    }
 
    area(): number {
        return Math.PI * this.radius ** 2;
    }
}
 
class Rectangle extends Shape {
    width: number;
    height: number;
 
    constructor(width: number, height: number) {
        super();
        this.width = width;
        this.height = height;
    }
 
    area(): number {
        return this.width * this.height;
    }
}
11 - Exercice : Interfaces hybrides12 - Exercice : Classes