Hériter des méthodes

Fait partie de la section Programmation orientée objet du Journey Lua de Coddy. Leçon 32 sur 70.

Une fois le lien d’héritage établi, les instances de la classe enfant ont automatiquement accès à toutes les méthodes parentes. Cela se produit grâce à la chaîne de recherche de Lua : lorsque vous appelez une méthode sur une instance, Lua parcourt chaque table connectée jusqu’à trouver ce que vous recherchez.

Considérez cette configuration où Animal définit une méthode :breathe() :

local Animal = {}
Animal.__index = Animal

function Animal:new()
    local obj = {}
    setmetatable(obj, Animal)
    return obj
end

function Animal:breathe()
    print("Breathing...")
end

-- Dog hérite de Animal
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

function Dog:new()
    local obj = {}
    setmetatable(obj, Dog)
    return obj
end

Regardez maintenant ce qui se passe lorsque nous créons un Dog et appelons la méthode du parent :

local buddy = Dog:new()
buddy:breathe()  -- Sortie : Breathing...

La classe Dog n’a jamais défini :breathe(), et pourtant cela fonctionne. Lua vérifie d’abord buddy, ne trouve rien, puis vérifie Dog, toujours rien, et finit par le trouver dans Animal. Cet héritage automatique des méthodes signifie que vous écrivez le comportement partagé une seule fois dans la classe parente, et que chaque classe enfant en bénéficie immédiatement.

Défi

Facile

Construisons une hiérarchie simple de créatures pour voir l’héritage des méthodes en action ! Tu vas créer une classe parente Animal et une classe enfant Dog, puis démontrer que les instances de Dog peuvent utiliser des méthodes définies uniquement dans Animal.

Tu organiseras ton code sur trois fichiers :

Animal.lua : définis ta classe parente avec le modèle de classe standard. Inclus un constructeur :new(name) qui stocke le nom de l’animal, ainsi qu’une méthode :speak() qui affiche le nom de l’animal suivi de makes a sound. Retourne la classe à la fin du fichier.
Dog.lua : définis ta classe enfant qui hérite de Animal. Importe le module Animal et configure le lien d’héritage afin que Dog puisse accéder aux méthodes d’Animal. Inclus un constructeur :new(name) qui stocke le nom et définit Dog comme métatable. La classe Dog ne doit PAS définir sa propre méthode :speak(). Elle l’héritera d’Animal.
main.lua : importe ton module Dog, lis un nom depuis l’entrée, crée une instance de Dog avec ce nom et appelle la méthode :speak() dessus.

Tu recevras une entrée : le nom du chien.

Par exemple, si l’entrée est Buddy, la sortie devrait être :

Buddy makes a sound

La magie, ici, c’est que ta classe Dog ne définit jamais :speak(), et pourtant son appel sur une instance de Dog fonctionne parfaitement. Lua suit la chaîne de recherche depuis l’instance Dog jusqu’à la classe Dog, puis jusqu’à la classe Animal où elle trouve la méthode. Voilà l’héritage en action !

Essayez vous-même

-- main.lua : Point d'entrée

local Dog = require('Dog')

-- Lire le nom du chien depuis l'entrée
local name = io.read()

-- TODO: Créer une instance de Dog avec le nom donné

-- TODO: Appeler la méthode :speak() sur l'instance du chien