Appeler des méthodes parentes

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

Parfois, surcharger complètement une méthode n'est pas ce que vous souhaitez. Au lieu de cela, vous pourriez vouloir étendre le comportement du parent — faire ce que le parent fait, puis ajouter quelque chose de supplémentaire. Pour y parvenir, vous pouvez appeler la méthode parente directement depuis la surcharge de l'enfant.

La technique utilise la syntaxe à point avec le nom de la classe parente, en passant explicitement self comme premier argument :

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

-- Dog étend le comportement parent
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

function Dog:new(name)
    local obj = Animal.new(Animal, name)
    setmetatable(obj, Dog)
    return obj
end

function Dog:speak()
    Animal.speak(self)  -- Appelle d'abord la méthode parente
    print(self.name .. " wags tail happily")
end

La ligne clé est Animal.speak(self). En utilisant la syntaxe par point sur la classe parente et en passant self manuellement, nous appelons la méthode d'origine avant d'ajouter notre propre comportement :

local buddy = Dog:new("Buddy")
buddy:speak()
-- Sortie :
-- Buddy fait un bruit
-- Buddy remue la queue joyeusement

Ce modèle est utile lorsque la méthode parente effectue un travail important que vous ne voulez pas dupliquer. L'enfant peut exécuter la logique du parent en premier, en dernier, ou même au milieu de son propre code — vous offrant un contrôle total sur la manière dont les comportements se combinent.

Défi

Facile

Construisons un système de salutation où une FormalPerson étend le comportement d'une Person ordinaire ! Au lieu de remplacer complètement la façon dont une personne se présente, la version formelle effectuera d'abord la présentation standard, puis ajoutera une touche de politesse supplémentaire.

Vous organiserez votre code sur trois fichiers :

Person.lua : Votre classe de base avec un constructeur :new(name) qui stocke le nom de la personne. Incluez une méthode :introduce() qui affiche le nom de la personne suivi de says hi. C'est le comportement de base qui sera étendu.
FormalPerson.lua : Une classe enfant qui hérite de Person. Son constructeur doit appeler le constructeur parent pour gérer le nom. Surchargez la méthode :introduce(), mais au lieu de remplacer entièrement le comportement du parent, appelez d'abord la méthode du parent en utilisant Person.introduce(self), puis affichez une ligne supplémentaire avec le nom de la personne suivi de bows politely.
main.lua : Importez votre module FormalPerson, lisez un nom depuis l'entrée, créez une instance de FormalPerson, et appelez :introduce() pour voir les deux comportements combinés.

Vous recevrez une entrée : le nom de la personne.

Lorsque vous appelez :introduce() sur une FormalPerson, cela devrait produire deux lignes de sortie — la première provenant de la méthode du parent, la seconde de l'ajout de l'enfant :

{name} says hi
{name} bows politely

Par exemple, si l'entrée est Eleanor, la sortie devrait être :

Eleanor says hi
Eleanor bows politely

L'idée clé ici est que FormalPerson ne duplique pas la logique "says hi" — elle délègue ce travail à la méthode parente, puis ajoute son propre comportement unique par-dessus. Cela permet de garder votre code propre et démontre comment les classes enfants peuvent étendre plutôt que remplacer les fonctionnalités parentes !

Aide-mémoire

Pour étendre le comportement d'une méthode parente au lieu de la remplacer complètement, appelez la méthode parente depuis la redéfinition de l'enfant en utilisant la syntaxe avec point et en passant explicitement self :

function ChildClass:method()
    ParentClass.method(self)  -- Appeler la méthode parente
    -- Ajouter un comportement supplémentaire
end

Exemple complet montrant l'extension de méthode :

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

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

function Dog:new(name)
    local obj = Animal.new(Animal, name)
    setmetatable(obj, Dog)
    return obj
end

function Dog:speak()
    Animal.speak(self)  -- Exécuter d'abord le comportement parent
    print(self.name .. " wags tail happily")  -- Ajouter le comportement de l'enfant
end

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

La méthode parente peut être appelée à n'importe quel moment : avant, après ou au milieu de la propre logique de l'enfant, offrant un contrôle total sur la manière dont les comportements se combinent.

Essayez vous-même

-- main.lua : Point d'entrée pour le système de salutation

local FormalPerson = require('FormalPerson')

-- Lire le nom de la personne à partir de l'entrée
local name = io.read()

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

-- TODO : Appeler la méthode introduce sur l'instance de FormalPerson