Mise en place de l'héritage
Fait partie de la section Object Oriented Programming du Journey Lua de Coddy — leçon 31 sur 70.
Jusqu'à présent, vous avez construit des classes où chaque objet recherche des méthodes dans une table de prototypes unique. Mais que se passe-t-il si vous voulez qu'une classe s'appuie sur une autre ? C'est là qu'intervient l'héritage : une classe enfant peut accéder à tout ce qui provient d'une classe parente tout en ajoutant ses propres fonctionnalités.
L'idée clé est qu'une table de classe elle-même peut avoir une métatable. Lorsque Lua ne trouve pas quelque chose dans la classe enfant, il regarde dans le __index de la métatable de l'enfant — qui pointe vers la classe parente.
-- Classe parente
local Animal = {}
Animal.__index = Animal
function Animal:new()
local obj = {}
setmetatable(obj, Animal)
return obj
end
function Animal:breathe()
print("Breathing...")
endVoici maintenant la configuration de l'héritage. Nous créons une classe enfant et définissons sa métatable pour qu'elle pointe vers le parent :
-- Classe enfant
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})Cette seule ligne — setmetatable(Dog, {__index = Animal}) — crée le lien d'héritage. Lorsqu'une instance de Dog appelle une méthode non trouvée dans Dog, Lua vérifie Animal.
La chaîne de recherche fonctionne comme ceci : instance → Dog → Animal. Chaque étape utilise __index pour trouver la table suivante à parcourir. Cela permet aux classes enfants d'hériter automatiquement de toutes les méthodes parentes sans les copier.
Défi
FacileConstruisons votre première hiérarchie d'héritage ! Vous allez créer une relation simple de classe parent-enfant où une classe Machine sert de base, et une classe Robot en hérite.
Vous organiserez votre code sur trois fichiers :
Machine.lua: Définissez votre classe parente avec le modèle de classe standard. Incluez un constructeur:new()et une méthode:status()qui afficheMachine is operational. N'oubliez pas de configurer__indexet de retourner la classe à la fin du fichier.Robot.lua: Définissez votre classe enfant qui hérite de Machine. Importez le module Machine avec require, configurez la table Robot avec son propre__index, et établissez le lien d'héritage en utilisantsetmetatable(Robot, {__index = Machine}). Incluez un constructeur:new()qui crée une instance avec Robot comme métatable.main.lua: Rassemblez le tout en important votre module Robot, en créant une instance de Robot et en appelant la méthode héritée:status().
Le concept clé ici est que votre classe Robot ne définit pas :status() elle-même — elle hérite de cette méthode de Machine via la chaîne de métatables. Lorsque vous appelez :status() sur une instance de Robot, Lua cherchera d'abord dans Robot, ne la trouvera pas, puis suivra le lien __index vers Machine où il découvrira la méthode.
Votre sortie devrait être :
Machine is operationalCette seule ligne prouve que l'héritage fonctionne — votre Robot a accédé avec succès à une méthode définie uniquement dans sa classe parente !
Aide-mémoire
Pour créer l'héritage en Lua, définissez la métatable d'une table de classe pour qu'elle pointe vers la classe parente en utilisant __index :
-- Classe parente
local Animal = {}
Animal.__index = Animal
function Animal:new()
local obj = {}
setmetatable(obj, Animal)
return obj
end
function Animal:breathe()
print("Breathing...")
end
-- Classe enfant
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})Le lien d'héritage est créé avec setmetatable(Dog, {__index = Animal}). Cela permet aux instances de Dog d'accéder automatiquement aux méthodes d'Animal.
La chaîne de recherche suit : instance → Classe enfant → Classe parente. Chaque étape utilise __index pour trouver la table suivante à explorer.
Essayez vous-même
-- main.lua : Tout mettre ensemble
-- À FAIRE : Importer le module Robot
-- À FAIRE : Créer une instance de Robot en utilisant Robot:new()
-- À FAIRE : Appeler la méthode héritée :status() sur votre instance de robot
-- Cela devrait afficher "Machine is operational"
Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.
Toutes les leçons de Object Oriented Programming
1Le concept de « self »
Tables avec fonctions« self » expliciteLa syntaxe avec deux-pointsPoint vs deux-pointsRécapitulatif - Point mobile4Projet : Banque numérique
Configuration du projetMéthode de dépôt7Polymorphisme et Redéfinition
Redéfinition de méthodesAppeler des méthodes parentesDuck TypingInterface communeVérification du typeRécapitulatif - Rôles des employés10Projet : Gestionnaire de formes
Configuration du projetClasse Rectangle2Modèle de prototype de classe
Le concept de prototypeLiaison avec __indexLe constructeur :new()Initialisation des attributsInstances indépendantesRécapitulatif - Usine de voitures5Surcharge d'opérateurs en POO
Additionner des objetsSoustraire des objetsConcaténer des objetsComparer des objets (<, >)Récapitulatif - Calculs de portefeuille8Encapsulation
Conventions de nommageClosures pour la confidentialitéAccès via les ClosuresTables en lecture seuleLogique de validationRécapitulatif - Coffre-fort sécurisé11Patrons de conception (Lite)
Fonctions FactoryTable SingletonPatron IteratorObserver (Écouteur)Récapitulatif - Logger Factory3État et comportement des objets
Variables d'instanceMéthodes GetterMéthodes SetterPropriétés calculéesFormatage de chaînesVérifications d'égalitéRécapitulatif - Note de l'étudiant6Bases de l'héritage
Mise en place de l'héritageHériter des méthodesÉtendre le constructeurAjouter des méthodes enfantsPartagé vs UniqueRécapitulatif - Hiérarchie des formes