TypeScript Classes

Les classes sont un concept fondamental de la programmation orientée objet (POO). Ce sont des modèles ou des plans pour créer des objets ayant les mêmes propriétés et méthodes. TypeScript prend entièrement en charge la programmation orientée objet, offrant des fonctionnalités telles que les classes, l'héritage et les modificateurs d'accès.

Les classes encapsulent les données (attributs) et le comportement (méthodes), ce qui rend le code plus modulaire, réutilisable et maintenable. Grâce aux classes, nous pouvons créer plusieurs objets ayant la même structure, et ces objets sont appelés instances de la classe.


Définition de classe

TypeScript utiliseclassle mot-clé `class` pour définir une classe. Une classe peut contenir les membres suivants :

  • Champ: Une variable déclarée dans la classe, représentant les attributs de l'objet
  • Constructeur: Une méthode spéciale appelée lors de l'instanciation de la classe, utilisée pour initialiser l'objet
  • Méthode: Une fonction définie dans la classe, représentant le comportement de l'objet

Format de syntaxe

class class_name {
    // 字段声明
    field1: type;
    field2: type;

    // 构造函数
    constructor(parameters) {
        // 初始化代码
    }

    // 方法
    methodName(): return_type {
        // 方法实现
    }
}

Exemple : Création d'une classe simple

Exemple

// Définir une classe Person vide
class Person {
}

JavaScript compilé :

Exemple

var Person = /** @class */ (function () {
    function Person() {
    }
    return Person;
}());

Champs de classe et constructeurs

Les champs de classe sont l’endroit où les données de l’objet sont stockées, et les constructeurs sont automatiquement appelés lorsqu’un objet est créé pour initialiser les champs.

Exemple

// Définir la classe Car
class Car {
// Champs : attributs décrivant la voiture
    engine: string;

// Constructeur : initialise engine lors de la création d’un objet
    constructor(engine: string) {
        this.engine = engine;
    }

// Méthode : afficher les informations sur engine
    disp(): void {
console.log("Modèle du moteur : " + this.engine);
    }
}

// Créer une instance de la classe
var car = new Car("moteur V8");

// Accéder à un champ
console.log("Lire le moteur : " + car.engine);

// Appeler une méthode
car.disp();

Sortie :

读取发动机: V8 发动机
发动机型号: V8 发动机

Explication :

  • thisLe mot-clé `this` fait référence à l'instance actuelle de la classe.
  • Les noms des paramètres du constructeur peuvent être identiques aux noms des champs, en utilisantthis.field`this` pour les distinguer.
  • Utilisernewle mot-clé `new` pour créer une instance de la classe.

Remarque :Les classes TypeScript sont converties en modèles constructeur/prototype JavaScript après compilation, et les interfaces n'apparaissent pas dans la sortie compilée.


Modificateurs de contrôle d'accès

TypeScript fournit trois modificateurs d'accès pour contrôler l'accessibilité des membres de classe :

Modificateur Description
public Membre public, accessible depuis n'importe où (par défaut)
private Membre privé, accessible uniquement au sein de la classe
protected Membre protégé, accessible au sein de la classe et de ses sous-classes

public (par défaut)

Exemple

class Person {
public name: string; // Attribut public
public age: number; // Attribut public

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

    public introduce(): void {
console.log("Je suis " + this.name + ", " + this.age + " ans");
    }
}

var person = new Person("Alice", 25);
console.log("Nom : " + person.name); // Accessible
person.introduce(); // Accessible

private

Exemple

class Person {
    public name: string;
private secret: string; // Attribut privé, non accessible directement depuis l'extérieur

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

// Les méthodes publiques peuvent accéder aux attributs privés
    public revealSecret(): void {
console.log("Secret: " + this.secret);
    }
}

var person = new Person("Alice", "I like programming");

console.log("Nom : " + person.name); // Accessible
// console.log(person.secret); // Erreur : 'secret' est une propriété privée

person.revealSecret(); // Accéder à la propriété privée via une méthode publique

protected

Exemple

class Person {
protected name: string; // Attribut protégé

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

    protected sayHello(): void {
console.log("Bonjour, je suis " + this.name);
    }
}

class Student extends Person {
    private grade: string;

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

    public introduce(): void {
// Les sous-classes peuvent accéder aux attributs et méthodes protégés
console.log("Je suis " + this.name + ", niveau : " + this.grade);
        this.sayHello();
    }
}

var student = new Student("Bob", "12e année");
student.introduce(); // Peut être accessible

// console.log(student.name); // Erreur : 'name' est une propriété protégée

Sortie :

我是 Bob,年级: 高三
你好,我是 Bob

Héritage de classe

L'héritage permet à une classe (sous-classe) d'acquérir des propriétés et des méthodes d'une autre classe (classe parente). Une sous-classe peut réutiliser le code de la classe parente et peut également étendre ou redéfinir le comportement de la classe parente.

Syntaxe de base

class child_class extends parent_class {
    // 子类新增的属性和方法
}

Héritage simple

Exemple

// Classe parente : Shape
class Shape {
    area: number;

    constructor(a: number) {
        this.area = a;
    }
}

// Sous-classe : Circle, héritant de Shape
class Circle extends Shape {
    disp(): void {
console.log("Aire du cercle : " + this.area);
    }
}

var circle = new Circle(223);
circle.disp();

Sortie :

圆的面积: 223

Héritage multiple

TypeScript ne prend pas en charge l'héritage multiple (une classe héritant de plusieurs classes), mais il prend en charge l'héritage à plusieurs niveaux (A hérite de B, B hérite de C) :

Exemple

// Classe racine
class Root {
    str: string;
}

// Sous-classe : hérite de Root
class Child extends Root {
}

// Classe feuille : hérite de Child (héritage à plusieurs niveaux)
class Leaf extends Child {
}

var leaf = new Leaf();
leaf.str = "hello";
console.log("valeur str : " + leaf.str);

Sortie :

str 值: hello

Redéfinition de méthode

Une sous-classe peut redéfinir une méthode de la classe parente, c'est-à-dire définir une méthode portant le même nom que la méthode de la classe parente dans la sous-classe pour implémenter son propre comportement.

Utilisersuperle mot-clé `super` pour appeler la méthode de la classe parente.

Exemple

// Classe parente
class PrinterClass {
    doPrint(): void {
console.log("Méthode doPrint() de la classe parente");
    }
}

// Sous-classe : redéfinition de la méthode de la classe parente
class StringPrinter extends PrinterClass {
    doPrint(): void {
// Appeler la méthode de la classe parente
        super.doPrint();

// Logique propre de la sous-classe
console.log("méthode doPrint() de la sous-classe");
    }
}

var obj = new StringPrinter();
obj.doPrint();

Sortie :

父类的 doPrint() 方法
子类的 doPrint() 方法

Membres statiques

Utiliserstaticle mot-clé `static` pour définir des membres qui appartiennent à la classe elle-même, et non aux instances de la classe. Ils sont accessibles directement via le nom de la classe sans créer d'instance.

Exemple

class StaticMem {
// Attribut statique
    static num: number;

// Méthode statique
    static disp(): void {
console.log("La valeur de num est " + StaticMem.num);
    }
}

// Accéder directement aux membres statiques via le nom de la classe
StaticMem.num = 12;
StaticMem.disp();

Résultat de l'exécution:

num 值为 12

Scénario d'application :Les membres statiques sont couramment utilisés pour définir des constantes de classe, des méthodes utilitaires ou des patrons singleton.


Opérateur instanceof

instanceofUtilisé pour déterminer si un objet est une instance d'une classe.

Exemple

class Person {
}

var obj = new Person();
var isPerson = obj instanceof Person;

console.log("Est-ce que obj est une instance de Person ? " + isPerson);

Résultat de l'exécution:

obj 是 Person 类的实例吗? true

Classes implémentant des interfaces

Une classe peut utiliser leimplementsmot-clé pour implémenter une interface, garantissant que la classe respecte le contrat défini par l'interface.

Exemple

// Définir l'interface
interface ILoan {
interest: number; // taux d'intérêt
}

// La classe implémente l'interface
class AgriLoan implements ILoan {
    interest: number;
rebate: number; // remise

    constructor(interest: number, rebate: number) {
        this.interest = interest;
        this.rebate = rebate;
    }
}

var loan = new AgriLoan(10, 1);
console.log("Taux d'intérêt : " + loan.interest + "%, remise : " + loan.rebate);

Résultat de l'exécution:

利率: 10%,回扣: 1

Classes abstraites

Les classes abstraites ne peuvent pas être instanciées, elles ne peuvent servir que de classes de base pour l'héritage par les sous-classes. Les classes abstraites peuvent contenir des méthodes abstraites (méthodes déclarées sans implémentation), que les sous-classes doivent implémenter.

Exemple

// Classe abstraite
abstract class Animal {
abstract makeSound(): void; // Méthode abstraite, doit être implémentée par les sous-classes

    move(): void {
console.log("L'animal se déplace");
    }
}

// Classe concrète : hérite de la classe abstraite
class Dog extends Animal {
    makeSound(): void {
console.log("Ouaf ouaf !");
    }
}

var dog = new Dog();
dog.move();
dog.makeSound();

Résultat de l'exécution:

The animal is moving
Woof woof woof!

Exemple complet

Application complète de diverses fonctionnalités des classes :

Exemple

// Définition de l'interface
interface I Printable {
    print(): void;
}

// Classe abstraite
abstract class Item {
    protected name: string;
    protected price: number;

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

    abstract getDetails(): string;
}

// Classe concrète
class Product extends Item implements I Printable {
    private category: string;

    constructor(name: string, price: number, category: string) {
        super(name, price);
        this.category = category;
    }

// Implémenter la méthode abstraite
    getDetails(): string {
return `Produit : ${this.name}, Prix : ¥${this.price}, Catégorie : ${this.category}`;
    }

// Implémenter la méthode d'interface
    print(): void {
        console.log(this.getDetails());
    }

// Méthode statique
    static create(name: string, price: number): Product {
return new Product(name, price, "Catégorie par défaut");
    }
}

// Utilisation
var product = Product.create("ordinateur portable", 5999);
product.print();

// Méthode de remise
class DiscountedProduct extends Product {
    private discount: number;

    constructor(name: string, price: number, category: string, discount: number) {
        super(name, price, category);
        this.discount = discount;
    }

    getDetails(): string {
        var discountedPrice = this.price * (1 - this.discount / 100);
return `Produit: ${this.name}, Prix d'origine: ¥${this.price}, Remise: ${this.discount}%, Prix actuel: ¥${discountedPrice.toFixed(2)}`;
    }
}

var discountedProduct = new DiscountedProduct("Téléphone", 2999, "Produits électroniques", 20);
discountedProduct.print();

Résultat de l'exécution:

产品: 笔记本电脑, 价格: ¥5999, 类别: 默认类别
产品: 手机, 原价: ¥2999, 折扣: 20%, 现价: ¥2399.20

Résumé

Les classes TypeScript offrent un support complet de programmation orientée objet :

  • Définition de classe: Utilise le mot-clé class, inclut des champs, des constructeurs et des méthodes
  • Modificateurs d'accès: public, private, protected contrôlent l'accès aux membres
  • Héritage: Utilise extends pour implémenter l'héritage de classe, prend en charge l'héritage à plusieurs niveaux
  • Redéfinition de méthode: Les sous-classes peuvent redéfinir les méthodes de la classe parente, utiliser super pour appeler la classe parente
  • Membres statiques: Utilisent le mot-clé static, appartiennent à la classe elle-même plutôt qu'aux instances
  • Implémentation d'interface: Utiliser le mot-clé implements pour implémenter des interfaces
  • Classes abstraites: Utilisent le mot-clé abstract, ne peuvent pas être instanciées, servent de classes de base

Les classes sont le fondement de la programmation orientée objet en TypeScript. Utiliser correctement les classes peut rendre le code plus structuré et plus maintenable.

Autres extensions