Hériter des méthodes

Fait partie de la section Object Oriented Programming du Journey Lua de Coddy — leçon 32 sur 70.

Une fois le lien d'héritage établi, les instances de la classe enfant accèdent automatiquement à toutes les méthodes parentes. Cela se produit via la chaîne de recherche de Lua : lorsque vous appelez une méthode sur une instance, Lua parcourt chaque table connectée jusqu'à ce qu'il trouve 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

Maintenant, regardez ce qui se passe lorsque nous créons un Dog et appelons la méthode du parent :

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

La classe Dog n'a jamais défini :breathe(), 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 de méthodes signifie que vous écrivez le comportement partagé une seule fois dans le parent 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 de méthodes en action ! Vous allez 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.

Vous organiserez votre code sur trois fichiers :

Animal.lua : Définissez votre classe parente avec le modèle de classe standard. Incluez un constructeur :new(name) qui stocke le nom de l'animal, et une méthode :speak() qui affiche le nom de l'animal suivi de makes a sound. Retournez la classe à la fin du fichier.
Dog.lua : Définissez votre classe enfant qui hérite d'Animal. Importez le module Animal et mettez en place le lien d'héritage pour que Dog puisse accéder aux méthodes d'Animal. Incluez 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 en héritera d'Animal.
main.lua : Importez votre module Dog, lisez un nom depuis l'entrée, créez une instance de Dog avec ce nom, et appelez la méthode :speak() sur celle-ci.

Vous recevrez 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 est que votre classe Dog ne définit jamais :speak(), pourtant l'appeler sur une instance de Dog fonctionne parfaitement. Lua suit la chaîne de recherche de l'instance Dog vers la classe Dog, puis vers la classe Animal où il trouve la méthode. C'est l'héritage à l'œuvre !

Aide-mémoire

Les instances de la classe enfant accèdent automatiquement à toutes les méthodes parentes via la chaîne de recherche de Lua. Lorsqu'une méthode est appelée sur une instance, Lua effectue une recherche à travers chaque table connectée jusqu'à ce qu'il trouve la méthode.

Mise en place de l'héritage

Définition de la 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 avec lien d'héritage :

local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

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

Utilisation des méthodes héritées

Les instances enfants peuvent appeler des méthodes parentes même si elles ne sont pas définies dans la classe enfant :

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

La chaîne de recherche : Lua vérifie buddy → Dog → Animal jusqu'à ce que la méthode soit trouvée.

Organisation des classes en plusieurs fichiers

Fichier de la classe parente (Animal.lua) :

local Animal = {}
Animal.__index = Animal

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

function Animal:speak()
    print(self.name .. " makes a sound")
end

return Animal

Fichier de la classe enfant (Dog.lua) :

local Animal = require("Animal")

local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

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

return Dog

Utilisation dans le fichier principal :

local Dog = require("Dog")
local buddy = Dog:new("Buddy")
buddy:speak()  -- Output: Buddy makes a sound

Essayez vous-même

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

local Dog = require('Dog')

-- Lire le nom du chien à partir de 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