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, tu as créé des classes où chaque objet recherche les méthodes dans une seule table de prototypes. Mais que faire si tu veux 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 essentielle est qu’une table de classe peut elle-même avoir une métatable. Lorsque Lua ne trouve pas quelque chose dans la classe enfant, il le cherche dans __index de la métatable de la classe enfant, qui pointe vers la classe parent.

-- 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 configurons sa métatable pour qu’elle consulte la classe parente :

-- 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 introuvable dans Dog, Lua vérifie Animal.

La chaîne de recherche fonctionne ainsi : instance → Dog → Animal. Chaque étape utilise __index pour trouver la table suivante dans laquelle effectuer la recherche. Cela permet aux classes enfants d’hériter automatiquement de toutes les méthodes parentes sans les copier.

Défi

Facile

Construisons ta première hiérarchie d’héritage ! Tu vas créer une relation simple de classe parent-enfant où une classe Machine sert de base, et où une classe Robot en hérite.

Tu vas organiser ton code sur trois fichiers :

Machine.lua : définis ta classe parent avec le modèle de classe standard. Inclus un constructeur :new() et une méthode :status() qui affiche Machine is operational. N’oublie pas de configurer __index et de retourner la classe à la fin du fichier.
Robot.lua : définis ta classe enfant qui hérite de Machine. Importe le module Machine, configure la table Robot avec son propre __index et établis le lien d’héritage à l’aide de setmetatable(Robot, {__index = Machine}). Inclus un constructeur :new() qui crée une instance ayant Robot comme métatable.
main.lua : rassemble tout en important ton module Robot, en créant une instance de Robot et en appelant la méthode héritée :status().

Le concept clé est que ta classe Robot ne définit pas elle-même :status(). Elle hérite de cette méthode de Machine par l’intermédiaire de la chaîne de métatables. Lorsque tu appelles :status() sur une instance de Robot, Lua cherche d’abord dans Robot, ne trouve pas la méthode, puis suit le lien __index vers Machine, où il découvre la méthode.

Ta sortie doit être :

Machine is operational

Cette seule ligne prouve que l’héritage fonctionne. Ton Robot a réussi à accéder à une méthode définie uniquement dans sa classe parent !

Essayez vous-même

-- main.lua: Rassembler le tout

-- TODO: Requérir le module Robot

-- TODO: Créer une instance de Robot en utilisant Robot:new()

-- TODO: Appeler la méthode héritée :status() sur votre instance de robot
-- This should print "Machine is operational"