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
class Person {
}
JavaScript compilé :
Exemple
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
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 utilisant
this.field`this` pour les distinguer. - Utiliser
newle 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
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
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
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
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
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
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
// 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
}
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
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
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
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