Classes et objets TypeScript : les bases de la programmation orientée objet

introduction

TypeScript est un sur-ensemble de JavaScript, qui ajoute des fonctionnalités de programmation orientées objet telles que des types statiques, des classes, des interfaces et des décorateurs à JavaScript, et compile TypeScript en JavaScript via un compilateur, qui peut s'exécuter dans n'importe quel environnement JavaScript. outil indispensable dans le développement JavaScript. La programmation orientée objet est la base des langages de programmation modernes, et les classes et les objets de TypeScript sont à la base de la mise en œuvre de la programmation orientée objet.

définition de classe

• Comme JavaScript, les classes dans TypeScript sont également définies à l'aide classdu mot-clé . La syntaxe pour définir une classe est la suivante :

  class ClassName {
        
        
      //类成员的定义
  }
  

• Les membres de classe peuvent contenir 属性, 方法, , 构造函数etc.静态成员

Les attributs

• Les attributs de classe peuvent être implémentés en définissant des variables directement dans la classe. Les propriétés peuvent être des variables ordinaires ou des objets de classe.

  class Person {
        
        
      name: string;
      age: number;
  }
  

• Dans l'exemple ci-dessus, nous avons défini une classe nommée Person, qui a deux propriétés, l'une est le nom et l'autre l'âge.

méthode

• Les méthodes d'une classe peuvent être function 关键字définies ou 箭头函数avec . 方法可以有返回值，也可以没有返回值.

  class Person {
        
        
      name: string;
      age: number;
      sayHello():void {
        
        
          console.log(`Hello, my name is ${
          
          this.name}, I'm ${
          
          this.age} years old`);
      }
      // 或者使用箭头函数的方式：sayHello: () => console.log(`Hello, my name is ${this.name}, I'm ${this.age} years old`)
  }
  

• Dans l'exemple ci-dessus, nous avons défini une classe nommée Person, qui a deux attributs, l'un est le nom et l'autre l'âge. Définit également une méthode appelée sayHello, qui n'a pas de valeur de retour et, lorsqu'elle est appelée, affiche le nom et l'âge de l'objet actuel.

Constructeur

• Les constructeurs de classe sont utilisés pour initialiser les objets de la classe. Comme JavaScript, les constructeurs TypeScript sont définis à l'aide du mot-clé constructeur.

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

• Dans l'exemple ci-dessus, nous avons défini une classe nommée Person, qui a deux propriétés, l'une est le nom et l'autre l'âge. Un constructeur est également défini, qui accepte une chaîne nommée name et une valeur nommée age, qui sont utilisées pour initialiser les propriétés name et age de l'objet courant.

membre statique

• Les membres statiques sont utilisés pour 在类的实例之间共享数据. Dans TypeScript, les membres statiques static 关键字sont .

  class Person {
        
        
      name: string;
      age: number;
      static total: number = 0;
      constructor(name: string, age: number) {
        
        
          this.name = name;
          this.age = age;
          Person.total++;
      }
  }
  

• Dans l'exemple ci-dessus, nous avons défini une classe nommée Person, qui a deux propriétés, l'une est le nom et l'autre l'âge. Un total de membres statiques est également défini pour enregistrer le nombre d'objets créés par la classe actuelle. Chaque fois que le constructeur est appelé, total sera incrémenté de 1, réalisant ainsi la mise à jour de total.

création d'objet

• Dans TypeScript, la création d'un objet nécessite d'abord la création d'une instance de la classe. Il existe deux manières de créer une instance de classe :

utiliser le nouveau mot clé

• new 关键字La création d'une instance d'une classe à l'aide est la méthode la plus courante.

  let person1 = new Person("Tom", 18);
  

• Dans l'exemple ci-dessus, nous avons créé une variable appelée person1, qui est une instance de la classe Person, et initialisé ses propriétés name et age à l'aide du constructeur.

Utiliser des littéraux d'objet

• Créer une instance de classe à l'aide 对象字面量est généralement utilisé pour créer une classe sans constructeur personnalisé.

  let person2: Person = {
        
        
      name: "Jerry",
      age: 20,
      sayHello: () => console.log("Hello")
  };
  

• Dans l'exemple ci-dessus, nous avons créé une variable appelée person2, qui est une instance de la classe Person, et initialisé ses propriétés name, age et sayHello à l'aide de littéraux d'objet.

Héritage et polymorphisme

hériter

• 继承属性Est un concept important dans la programmation orientée objet, qui permet à une classe d'hériter et d'hériter d'une autre classe 方法. Comme JavaScript, dans TypeScript, l'héritage est défini à l'aide du mot clé extend.

  class Student extends Person {
        
        
      grade: number;
      constructor(name: string, age: number, grade: number) {
        
        
          super(name, age);
          this.grade = grade;
      }
      sayHello(): void{
        
        
          console.log(`Hello, my name is ${
          
          this.name}, I'm ${
          
          this.age} years old, I'm in grade ${
          
          this.grade}`);
      }
  }
  

• Dans l'exemple ci-dessus, nous avons défini une classe nommée Student, qui a hérité de toutes les propriétés et méthodes de la classe Person, et ajouté un attribut nommé grade pour indiquer la note de l'étudiant. La méthode sayHello de la classe parent est également réécrite pour afficher toutes les propriétés de l'objet actuel.

polymorphisme

• 多态C'est un concept important dans la programmation orientée objet, qui permet à différents objets de se comporter différemment lors de l'appel de la même méthode. Dans TypeScript, l'implémentation du polymorphisme nécessite l'utilisation 抽象类de et 接口.

• 抽象类是一种不能被直接实例化的类，它只能被继承. Les classes abstraites peuvent contenir 抽象方法et 普通方法.

  • 抽象方法是没有实现的方法，它的实现需要在子类中完成。

  abstract class Animal {
        
        
      abstract makeSound(): void;
      move(): void {
        
        
          console.log("I'm moving");
      }
  }
  

• Dans l'exemple ci-dessus, nous avons défini une classe abstraite nommée Animal, qui a une méthode abstraite makeSound et une méthode normale move. La méthode makeSound n'est pas implémentée et doit être effectuée dans des sous-classes.

• 接口Est un type utilisé pour définir la structure, les propriétés et les méthodes d'un objet.

  • 接口只是一个类型声明，它没有实现任何行为。

  interface Shape {
        
        
      area(): number;
  }
  class Circle implements Shape {
        
        
      radius: number;
      constructor(radius: number) {
        
        
          this.radius = radius;
      }
      area(): number {
        
        
          return this.radius * this.radius * Math.PI;
      }
  }
  class Square implements Shape {
        
        
      length: number;
      constructor(length: number) {
        
        
          this.length = length;
      }
      area(): number {
        
        
          return this.length * this.length;
      }
  }
  

• Dans l'exemple ci-dessus, nous avons défini une interface appelée Shape, qui a une méthode appelée area. Définit également deux classes qui implémentent l'interface Shape, Circle et Square, toutes deux implémentent la méthode de surface, mais la manière de calculer la surface est différente.

Résumer

Les classes et les objets sont 面向对象编程la base. Grâce à la définition des classes, nous pouvons créer des objets et encapsuler des propriétés et des méthodes. Grâce à l'héritage et au polymorphisme, nous pouvons réaliser la réutilisation et l'extension du code. TypeScript améliore encore les capacités de programmation orientée objet de JavaScript en ajoutant des fonctionnalités telles que le typage statique, les classes, les interfaces et les décorateurs. La maîtrise des classes et des objets TypeScript peut nous aider à développer rapidement des applications JavaScript de haute qualité.