Classes et Objets en Typescript

Sommaire

Classes en Typescript
Objets en Typescript
Conclusion

Après avoir découvert les interfaces et les types personnalisés, il est temps de s'attaquer à un concept fondamental en POO : les classes et les objets.

Let's go !

Classes en Typescript

Une classe en Typescript est une structure qui nous permet de créer des objets avec des propriétés et des méthodes. Elle est définie avec le mot-clé class.

Définir une Classe

Imaginons que nous créons un jeu où nous devons manipuler des personnages.

Nous allons créer une classe pour représenter un personnage :

class Character {
  name: string
  health: number
  mana: number

  constructor(name: string, health: number, mana: number) {
    this.name = name
    this.health = health
    this.mana = mana
  }

  attack(): string {
    return `${this.name} attacks with a powerful strike!`
  }
}

let hero = new Character('Aragorn', 100, 50)
console.log(hero.attack())

Dans cet exemple, la classe Character a trois propriétés : name, health, et mana. Le constructeur initialise ces propriétés, et la méthode attack retourne une action.

Héritage

L'héritage permet de créer une nouvelle classe à partir d'une classe existante.

Utilisons l'héritage pour créer une classe Mage qui hérite de Character :

class Mage extends Character {
  magicPower: number

  constructor(name: string, health: number, mana: number, magicPower: number) {
    super(name, health, mana) // Appelle le constructeur de la classe parent
    this.magicPower = magicPower
  }

  castSpell(): string {
    return `${this.name} casts a spell with power ${this.magicPower}!`
  }
}

let mage = new Mage('Gandalf', 80, 200, 150)
console.log(mage.attack())
console.log(mage.castSpell())

Ici, Mage hérite de Character, ce qui signifie qu'il peut utiliser les propriétés et méthodes de Character, mais aussi ajouter ses propres propriétés et méthodes.

Modificateurs d'Accès

Typescript propose trois modificateurs d'accès : public, private, et protected.

public : Accessible partout.
private : Accessible uniquement au sein de la classe.
protected : Accessible dans la classe et ses sous-classes.

class TreasureChest {
  public gold: number
  private isOpen: boolean

  constructor(gold: number) {
    this.gold = gold
    this.isOpen = false
  }

  public open(): void {
    if (!this.isOpen) {
      console.log('The chest is now open!')
      this.isOpen = true
    } else {
      console.log('The chest is already open.')
    }
  }

  public takeGold(): number {
    if (this.isOpen) {
      const goldTaken = this.gold
      this.gold = 0
      return goldTaken
    } else {
      console.log("The chest is closed. You can't take the gold.")
      return 0
    }
  }
}

let chest = new TreasureChest(100)
chest.open()
console.log(`You take ${chest.takeGold()} gold coins.`)

Dans cet exemple, isOpen est privée, donc accessible uniquement au sein de la classe TreasureChest.

Méthodes et Propriétés Statique

Les méthodes et propriétés statiques appartiennent à la classe elle-même plutôt qu'à une instance spécifique.

class GameUtil {
  static gameName: string = 'Epic Adventure'

  static startGame(): void {
    console.log(`Starting game: ${this.gameName}`)
  }
}

console.log(GameUtil.gameName) // Epic Adventure
GameUtil.startGame() // Starting game: Epic Adventure

Objets en Typescript

Les objets sont des instances de classes. Tu peux créer des objets en utilisant le mot-clé new suivi du nom de la classe.

Création d'Objets

Voici comment créer et utiliser des objets en Typescript :

class Weapon {
  name: string
  damage: number

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

  use(): string {
    return `${this.name} deals ${this.damage} damage!`
  }
}

let sword = new Weapon('Excalibur', 50)
console.log(sword.use())

Conclusion

Les classes et les objets en Typescript sont des outils puissants pour structurer et gérer ton code de manière efficace.

Ils te permettent de créer des programmes robustes, réutilisables et faciles à maintenir.