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"