TypeScript - Classes Abstraites

Bonjour là-bas, futurs programmeurs ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde de TypeScript et explorer l'une de ses fonctionnalités puissantes : les Classes Abstraites. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; je vais vous guider à travers ce concept étape par étape, tout comme j'ai fait pour des centaines d'étudiants au cours de mes années d'enseignement. Alors, plongeons dedans !

Qu'est-ce qu'une Classe Abstraite ?

Avant de plonger dans les détails des classes abstraites, penchons-nous sur une simple analogie. Imaginez que vous êtes dans une concession automobile et que vous voyez une pancarte qui dit "Véhicule". Vous ne pouvez pas vraiment acheter un "Véhicule" parce que c'est trop générique. Vous devez choisir un type spécifique de véhicule, comme une voiture, un camion ou une moto. Dans la programmation, une classe abstraite est comme ce concept général de "Véhicule" - c'est un plan pour d'autres classes, mais vous ne pouvez pas créer un objet directement à partir de celle-ci.

Les classes abstraites en TypeScript servent de classes de base à partir desquelles d'autres classes peuvent hériter. Elles peuvent contenir des méthodes abstraites (méthodes sans corps) et des méthodes concrètes (méthodes avec un corps). La chose clé à retenir est que vous ne pouvez pas créer une instance d'une classe abstraite directement.

Créer des Classes Abstraites

Maintenant, voyons comment nous créons une classe abstraite en TypeScript. Nous utilisons le mot-clé abstract avant le mot-clé class. Voici une structure de base :

abstract class ClassName {
// Propriétés et méthodes vont ici
}

Méthodes Abstraites

Les classes abstraites peuvent avoir des méthodes abstraites. Ce sont des méthodes déclarées mais sans implémentation dans la classe abstraite. Toute classe qui étend cette classe abstraite doit fournir une implémentation pour ces méthodes.

Méthodes Concrètes

Les classes abstraites peuvent également avoir des méthodes concrètes, qui sont des méthodes pleinement implémentées et peuvent être héritées par les classes enfant.

Exemple 1 : La Classe Abstraite Shape

Créons un exemple simple pour illustrer comment fonctionnent les classes abstraites. Nous allons créer une classe abstraite Shape avec une méthode abstraite calculateArea().

abstract class Shape {
color: string;

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

abstract calculateArea(): number;

displayColor(): void {
console.log(`This shape is ${this.color}`);
}
}

Dans cet exemple :

• Shape est notre classe abstraite.
• color est une propriété que toutes les formes auront.
• calculateArea() est une méthode abstraite. Notez qu'elle n'a pas de corps, seulement une déclaration.
• displayColor() est une méthode concrète que toutes les formes peuvent utiliser tel quel.

Maintenant, créons quelques formes spécifiques qui étendent notre classe Shape :

class Circle extends Shape {
radius: number;

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

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

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

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

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

Maintenant nous pouvons utiliser ces classes :

const circle = new Circle("red", 5);
console.log(circle.calculateArea()); // Output: 78.53981633974483
circle.displayColor(); // Output: This shape is red

const rectangle = new Rectangle("blue", 4, 6);
console.log(rectangle.calculateArea()); // Output: 24
rectangle.displayColor(); // Output: This shape is blue

Dans cet exemple, Circle et Rectangle étendent la classe Shape et fournissent leur propre implémentation de la méthode calculateArea(). Ils héritent également de la méthode displayColor() de la classe Shape.

Exemple 2 : La Classe Abstraite Animal

Créons un autre exemple pour renforcer notre compréhension. Cette fois, nous allons créer une classe abstraite Animal :

abstract class Animal {
name: string;

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

abstract makeSound(): void;

move(distance: number = 0): void {
console.log(`${this.name} moved ${distance} meters.`);
}
}

class Dog extends Animal {
constructor(name: string) {
super(name);
}

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

class Cat extends Animal {
constructor(name: string) {
super(name);
}

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

Utilisons ces classes :

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Woof! Woof!
dog.move(10); // Output: Buddy moved 10 meters.

const cat = new Cat("Whiskers");
cat.makeSound(); // Output: Meow!
cat.move(5); // Output: Whiskers moved 5 meters.

Dans cet exemple, Animal est notre classe abstraite avec une méthode abstraite makeSound() et une méthode concrète move(). Dog et Cat étendent Animal et fournissent leur propre implémentation de la méthode makeSound().

Pourquoi Utiliser des Classes Abstraites ?

Vous pourriez vous demander, "Pourquoi prendre tout ce mal ? Pourquoi ne pas utiliser des classes régulières ?" Eh bien, les classes abstraites sont extrêmement utiles lorsque vous voulez définir une interface commune pour un ensemble de classes apparentées. Elles vous permettent de :

1. Définir une structure commune pour un groupe de classes apparentées.
2. Imposer que certaines méthodes soient implémentées par les classes enfant.
3. Fournir certaines fonctionnalités communes que toutes les classes enfant peuvent utiliser.

Envisagez-le comme la création d'un modèle ou d'un contrat que d'autres classes doivent suivre. C'est un moyen d'assurer la cohérence entre les classes apparentées tout en permettant une personnalisation là où elle est nécessaire.

Méthodes dans les Classes Abstraites

Voici un tableau résumant les types de méthodes que vous pouvez avoir dans les classes abstraites :

Type de Méthode	Description	Peut-être appelée sur la classe abstraite ?	Doit être implémentée par la classe enfant ?
Méthode Abstraite	Déclarée sans implémentation	Non	Oui
Méthode Concrète	Méthode pleinement implémentée	Oui	Non (peut être surchargée)

Conclusion

Et voilà, les amis ! Nous avons fait le voyage à travers le territoire des classes abstraites en TypeScript. Depuis la compréhension de ce qu'elles sont, jusqu'à leur création et leur utilisation avec des exemples du monde réel, vous avez maintenant une bonne base dans cette fonctionnalité puissante de TypeScript.

Souvenez-vous, les classes abstraites sont comme les plans pour un bâtiment. Elles fournissent la structure et certains détails, mais il incombe aux classes qui les étendent de combler les spécificités et de les rendre vivantes.

Alors que vous continuez votre voyage en programmation, vous trouverez les classes abstraites être des outils extrêmement utiles dans votre boîte à outils TypeScript. Elles vous aident à écrire du code plus propre, plus organisé et plus maintenable. Alors, continuez à abstraire à votre guise !

Bonne programmation, et jusqu'à la prochaine fois, continuez à explorer et à apprendre !

Credits: Image by storyset