Appeler des méthodes parentes

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

Parfois, remplacer complètement une méthode n'est pas ce que vous souhaitez. Vous pouvez plutôt vouloir étendre le comportement du parent : faire ce que fait le parent, puis ajouter quelque chose en plus. Pour y parvenir, vous pouvez appeler directement la méthode du parent depuis la redéfinition de l'enfant.

La technique utilise la syntaxe avec un point et le nom de la classe parente, en transmettant 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 du 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)  -- Appeler d'abord la méthode parente
    print(self.name .. " wags tail happily")
end

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

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

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

Défi

Facile

Construisons un système de salutations dans lequel FormalPerson étend le comportement d’un Person ordinaire ! Au lieu de remplacer complètement la manière dont une personne se présente, la version formelle commencera par effectuer 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 enregistre le nom de la personne. Incluez une méthode :introduce() qui affiche le nom de la personne suivi de says hi. Il s’agit du 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. Remplacez la méthode :introduce(), mais au lieu de remplacer entièrement le comportement du parent, appelez d’abord la méthode du parent avec Person.introduce(self), puis affichez une ligne supplémentaire contenant 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 un FormalPerson, deux lignes doivent être produites : la première par la méthode du parent, la seconde par l’ajout de l’enfant :

{name} says hi
{name} bows politely

Par exemple, si l’entrée est Eleanor, la sortie doit être :

Eleanor says hi
Eleanor bows politely

L’idée essentielle ici est que FormalPerson ne duplique pas la logique de « says hi ». Elle délègue cette tâche à la méthode du parent, puis ajoute son propre comportement unique par-dessus. Cela permet de garder un code propre et montre comment les classes enfants peuvent étendre les fonctionnalités du parent plutôt que les remplacer !

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 depuis 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