🧬 Héritage en TypeScrip

📦 Principe de base

En TypeScript (comme en JavaScript), on utilise le mot-clé extends pour indiquer qu’une classe hérite d’une autre.

📌 Exemple simple d’héritage

📋 Copier le code

class Animal {
constructor(public nom: string) {}

parler(): string {
return \`\${this.nom} fait un bruit.\`;
}
}

class Chien extends Animal {
aboyer(): string {
return \`\${this.nom} aboie : Woof!\`;
}
}

const monChien = new Chien("Rex");
console.log(monChien.parler()); // Hérité
console.log(monChien.aboyer()); // Spécifique à Chien

• Chien hérite de Animal grâce à extends
• Il a accès à nom et à la méthode parler()
• Il possède aussi sa propre méthode aboyer()

🔁 Redéfinir une méthode héritée (surcharge)

Une classe fille peut remplacer une méthode héritée pour personnaliser son comportement.

📋 Copier le code

class Chat extends Animal {
parler(): string {
return \`\${this.nom} dit : Miaou !\`;
}
}

const monChat = new Chat("Minou");
console.log(monChat.parler()); // Appelle la méthode redéfinie

• On redéfinit ici parler() dans la classe Chat
• Elle remplace la version de la classe parente Animal

🔧 Utiliser super() dans un constructeur hérité

Lorsqu'une classe hérite d'une autre, elle doit appeler le constructeur parent avec super().

📋 Copier le code

class Vehicule {
constructor(public marque: string) {}
}

class Voiture extends Vehicule {
constructor(marque: string, public modele: string) {
super(marque); // Appelle le constructeur de Vehicule
}

afficher(): string {
return \`\${this.marque} \${this.modele}\`;
}
}

const maVoiture = new Voiture("Toyota", "Corolla");
console.log(maVoiture.afficher());

• super(marque) appelle le constructeur de la classe parente
• On ajoute ensuite modele dans la classe Voiture

📌 Résumé

• extends permet à une classe d’en hériter une autre
• La classe fille peut utiliser les propriétés et méthodes de la classe parent
• Elle peut redéfinir certaines méthodes (surcharge)
• Elle doit utiliser super() dans son constructeur si elle en a un

🧭 Prochaine étape

Dans le chapitre suivant, nous allons découvrir les **interfaces orientées objet** : comment elles permettent de décrire des contrats pour les classes et d'améliorer encore la robustesse du typage.

Souhaites-tu passer au Chapitre 4 du Module 2 : Interfaces orientées objet en TypeScript ?