Classes abstraites TypeScript
Les classes abstraites sont un concept important dans la programmation orientée objet en TypeScript.
C'est une classe qui ne peut pas être instanciée directement et qui ne peut servir que de classe de base pour que d'autres classes en héritent.
Les classes abstraites sont principalement utilisées pour définir des propriétés et des méthodes communes aux sous-classes, en fournissant un modèle de structure et de comportement unifié pour les sous-classes.
Diagramme SVG : hiérarchie d'héritage des classes abstraites
Pourquoi les classes abstraites sont nécessaires
En programmation orientée objet, nous avons souvent besoin de définir des classes de base.
Ces classes de base décrivent des propriétés et des méthodes communes aux sous-classes, mais les détails d'implémentation de certaines méthodes doivent être décidés par les sous-classes elles-mêmes.
Les classes abstraites permettent de résoudre ce problème : elles nous permettent de définir des signatures de méthodes (déclarations) tout en laissant l'implémentation concrète aux sous-classes.
Explication du concept :Une classe abstraite est un type intermédiaire entre une classe normale et une interface. Elle possède à la fois les caractéristiques d'une interface (définition de signatures de méthodes) et les caractéristiques d'une classe (peut avoir des implémentations de méthodes concrètes et des constructeurs).
Notions de base sur les classes abstraites
Utiliserabstractle mot-clé `abstract` pour déclarer des classes abstraites et des méthodes abstraites.
Les classes abstraites peuvent contenir des méthodes abstraites et des méthodes concrètes (méthodes avec une implémentation existante).
Exemple
// Une classe abstraite ne peut pas être instanciée directement ; elle peut seulement servir de classe de base
abstract class Animal {
// Propriété du nom de l'animal
name: string;
// Constructeur
constructor(name: string) {
this.name = name;
}
// Méthode abstraite : modifiée avec abstract, sans corps de méthode
// Les sous-classes doivent implémenter cette méthode
abstract speak(): void;
// Méthode concrète : une méthode avec une implémentation spécifique
// Les sous-classes peuvent directement en hériter et l'utiliser sans la redéfinir
move(): void {
console.log(this.name + " se déplace");
}
}
// Tenter d'instancier une classe abstraite provoquera une erreur
// var animal = new Animal("Animal"); // Erreur : impossible d'instancier une classe abstraite
// Définir la classe Dog qui hérite de Animal
class Dog extends Animal {
// La sous-classe doit implémenter la méthode abstraite speak() de la classe parente
speak(): void {
console.log(this.name + " Woof woof!");
}
}
// Créer une instance de Dog
var dog = new Dog("Wangcai");
dog.speak(); // Appeler la méthode implémentée par la sous-classe
dog.move(); // Hériter de la méthode concrète de la classe parente
Sortie :
Wangcai, woof woof woof! Wangcai is moving.
Explication :Les méthodes abstraites n'ont pas de corps de méthode (seulement une signature de méthode), et les sous-classes doivent les implémenter. Les méthodes concrètes ont des implémentations spécifiques, et les sous-classes peuvent directement les hériter et les utiliser.
Méthodes abstraites
Les méthodes abstraites sont des méthodes déclarées mais non implémentées dans une classe abstraite.
Après qu'une sous-classe hérite d'une classe abstraite, elle doit implémenter toutes les méthodes abstraites ; sinon, une erreur se produira.
Exemple
abstract class Shape {
// Méthode abstraite : déclaration uniquement, pas d'implémentation
// Les sous-classes doivent implémenter ces deux méthodes
abstract area(): number;
abstract perimeter(): number;
// Méthode concrète : peut utiliser des méthodes abstraites
// Cette méthode appelle une méthode abstraite ; les sous-classes peuvent l'utiliser normalement après héritage
describe(): void {
console.log("Aire : " + this.area().toFixed(2));
}
}
// Définir une classe rectangle qui hérite de Shape
class Rectangle extends Shape {
// Largeur du rectangle
width: number;
// Hauteur du rectangle
height: number;
// Constructeur
constructor(width: number, height: number) {
super(); // Appeler le constructeur de la classe parente
this.width = width;
this.height = height;
}
// Implémenter la méthode abstraite : calculer l'aire
area(): number {
return this.width * this.height;
}
// Implémenter la méthode abstraite : calculer le périmètre
perimeter(): number {
return 2 * (this.width + this.height);
}
}
// Créer une instance de rectangle
var rect = new Rectangle(4, 5);
// Appeler la méthode describe héritée, qui appelle en interne la méthode area de la sous-classe
rect.describe();
console.log("Périmètre : " + rect.perimeter());
Sortie :
面积: 20.00 周长: 18
Astuce :Les méthodes concrètes peuvent appeler des méthodes abstraites. En effet, lorsqu'une méthode concrète est appelée, la sous-classe a déjà implémenté la méthode abstraite, elle peut donc s'exécuter normalement.
Classe abstraite en tant que type
Une classe abstraite peut être utilisée comme type de paramètre.
Cela signifie qu'une fonction peut accepter des instances de n'importe quelle sous-classe de la classe abstraite, ce qui permet le polymorphisme.
Exemple
abstract class Animal {
// Méthode abstraite : tous les animaux émettent des sons
abstract speak(): void;
}
// Définir la classe Cat qui hérite d'Animal
class Cat extends Animal {
// Implémenter la méthode abstraite
speak(): void {
console.log("Miaou miaou miaou !");
}
}
// Définir la classe Dog qui hérite d'Animal
class Dog extends Animal {
// Implémenter la méthode abstraite
speak(): void {
console.log("Ouaf ouaf ouaf !");
}
}
// Définir le type du paramètre de la fonction comme la classe abstraite Animal
// Cette fonction peut accepter n'importe quelle instance de sous-classe de Animal
function makeSpeak(animal: Animal): void {
animal.speak();
}
// Passer différentes instances de sous-classe produit des comportements différents (polymorphisme)
makeSpeak(new Cat());
makeSpeak(new Dog());
// Tableau de type classe abstraite : peut stocker des instances de différentes sous-classes
var animals: Animal[] = [new Cat(), new Dog()];
Sortie :
Meow meow meow! Woof woof woof!
Polymorphisme :Lorsqu'une classe abstraite est utilisée comme type, l'implémentation de méthode réellement exécutée est celle de la sous-classe. C'est la caractéristique de polymorphisme de la programmation orientée objet.
Différences entre les classes abstraites et les interfaces
Les classes abstraites et les interfaces servent toutes deux à définir des spécifications de type, mais il existe des différences clés.
Comprendre leurs différences aide à faire le bon choix dans le développement réel.
| Fonctionnalité | Classe abstraite | Interface |
|---|---|---|
| Instanciation | Ne peut pas être instanciée directement | Ne peut pas être instanciée directement |
| Implémentation de méthode | Peut avoir des implémentations concrètes | Ne peut avoir que des déclarations (TypeScript 3.6+ peut avoir des implémentations par défaut) |
| Modificateurs de membre | Peut ajouter public, protected, private | Ne peut avoir que readonly |
| Héritage | Héritage simple (ne peut étendre qu'une seule classe) | Implémentation multiple (peut implémenter plusieurs interfaces) |
| Constructeur | Peut avoir un constructeur | Ne peut pas avoir de constructeur |
Suggestions de sélection :Utilisez des classes abstraites lorsque du code partagé est nécessaire ; utilisez des interfaces lorsque des spécifications/contrats doivent être définis ; utilisez des interfaces lorsque l'héritage multiple est nécessaire.
Exemple complet : Système de paiement
Voici un exemple de système de paiement implémenté à l'aide d'une classe abstraite.
Cet exemple démontre l'application des classes abstraites dans des projets réels.
Exemple
abstract class Payment {
// Méthode abstraite : traiter le paiement, les sous-classes doivent l'implémenter
abstract process(amount: number): boolean;
// Méthode concrète : vérifier les informations de paiement
// Toutes les sous-classes peuvent utiliser cette méthode
validate(): void {
console.log("Vérifier les informations de paiement");
}
}
// Classe de paiement par carte de crédit
class CreditCardPayment extends Payment {
// Numéro de carte de crédit
cardNumber: string;
// Constructeur
constructor(cardNumber: string) {
super(); // Appeler le constructeur de la classe parente
this.cardNumber = cardNumber;
}
// Implémenter la méthode abstraite : traiter le paiement par carte de crédit
process(amount: number): boolean {
console.log("Traitement du paiement par carte de crédit : " + amount);
return true;
}
}
// Classe de paiement PayPal
class PayPalPayment extends Payment {
// E-mail PayPal
email: string;
// Constructeur
constructor(email: string) {
super();
this.email = email;
}
// Implémenter la méthode abstraite : traiter le paiement PayPal
process(amount: number): boolean {
console.log("Traitement du paiement PayPal : " + amount);
return true;
}
}
// Utiliser le polymorphisme pour gérer différentes méthodes de paiement
var payments: Payment[] = [
new CreditCardPayment("1234"),
new PayPalPayment("test@example.com")
];
// Parcourir et traiter chaque méthode de paiement
for (var _i = 0, payments_1 = payments; _i < payments_1.length; _i++) {
var payment = payments_1[_i];
// Appeler la méthode de vérification héritée
payment.validate();
// Appeler la méthode de traitement de la sous-classe
payment.process(100);
}
Sortie :
验证支付信息 处理信用卡支付: 100 验证支付信息 处理 PayPal 支付: 100
Scénarios d'application :Les classes abstraites sont souvent utilisées dans la conception de frameworks et la stratification de la logique métier. Par exemple, le traitement des paiements, l'authentification des utilisateurs, la persistance des données et d'autres scénarios.
Notes
- Ne peut pas être instanciée :Les classes abstraites ne peuvent pas être instanciées directement avec new ; elles doivent être héritées par des sous-classes
- Les méthodes abstraites doivent être implémentées :Une erreur se produit si une sous-classe n'implémente pas toutes les méthodes abstraites
- Peut avoir des constructeurs :Les classes abstraites peuvent définir des constructeurs, et les sous-classes doivent appeler super()
- Héritage simple :Une classe ne peut hériter que d'une seule classe abstraite (héritage simple)
- Modificateurs d'accès :Les méthodes abstraites peuvent utiliser les modificateurs public et protected
Bonnes pratiques :Utilisez des classes abstraites lorsque plusieurs classes doivent partager du code et de la logique. Utilisez des interfaces lorsque seules des spécifications et des contrats doivent être définis.
Résumé
Les classes abstraites sont une partie importante de la programmation orientée objet en TypeScript.
- Le mot-clé abstract :Utilisé pour déclarer des classes et méthodes abstraites
- Ne peut pas être instanciée :Ne peut être utilisée que via l’héritage par les sous-classes
- Méthodes abstraites :Méthodes que les sous-classes doivent implémenter
- Méthodes concrètes :Méthodes implémentées que les sous-classes peuvent directement hériter et utiliser
- Patron de méthode modèle :Les classes abstraites définissent le squelette, les sous-classes fournissent les implémentations concrètes
Autres extensionsRecommandation :Lors de la conception de hiérarchies de classes, privilégiez l’utilisation de classes abstraites pour partager du code et définir des spécifications.