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 Background Title Abstract Class Inheritance Hierarchy Structure Abstract class Animal abstract class Animal Cannot be instantiated directly Arrows to subclasses Subclass Dog class Dog extends Animal Subclass Cat class Cat extends Animal Abstract method description Abstract class features Feature list abstract method: subclasses must implement it Concrete method: subclasses can use it directly Can be used as a type: accepts subclass instances Arrow marker

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

// Utilisez le mot-clé abstract pour déclarer une classe abstraite
// 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

// Définir la classe abstraite Shape
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

// Définir la classe abstraite Animal
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

// Définir la classe abstraite de paiement
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

Recommandation :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.

Autres extensions