Mise en place de l'héritage

Fait partie de la section Programmation orientée objet 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...")
end

Voici 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

Facile

Construisons 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 affiche Machine is operational. N'oubliez pas de configurer __index et 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 utilisant setmetatable(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 operational

Cette 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 !

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"