Redéfinition de méthodes

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

Jusqu’à présent, les classes enfants ont hérité des méthodes des classes parentes et en ont ajouté de nouvelles. Mais que faire si une classe enfant a besoin du même nom de méthode avec un comportement différent ? Cela s’appelle la surcharge de méthode.

Lorsque vous définissez une méthode dans une classe enfant portant le même nom que celle de la classe parente, la version de la classe enfant est prioritaire. La chaîne de recherche de Lua vérifie d’abord la classe enfant et, si elle y trouve la méthode, elle cesse de chercher.

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 redéfinit speak()
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()
    print(self.name .. " barks: Woof!")
end

À présent, chaque classe réagit différemment au même appel de méthode :

local generic = Animal:new("Creature")
local buddy = Dog:new("Buddy")

generic:speak()  -- Sortie : Creature fait un son
buddy:speak()    -- Sortie : Buddy aboie : Woof!

La méthode :speak() de Dog remplace complètement la version du parent pour les instances de Dog. Cela vous permet de créer un comportement spécialisé tout en conservant une interface cohérente : chaque animal peut utiliser :speak(), mais chaque espèce le fait différemment.

Défi

Facile

Construisons un petit royaume animalier où différentes créatures s’expriment chacune à leur manière ! Vous allez créer une classe parente Animal et deux classes enfants, Cat et Cow, qui redéfiniront chacune la méthode :speak() de la classe parente avec leur propre comportement spécialisé.

Vous organiserez votre code dans quatre fichiers :

Animal.lua : votre classe de base avec un constructeur :new(name) qui stocke le nom de l’animal. Incluez une méthode :speak() qui affiche le nom de l’animal suivi de makes a sound. Il s’agit du comportement par défaut que les classes enfants redéfiniront.
Cat.lua : une classe enfant qui hérite de Animal. Son constructeur :new(name) doit appeler le constructeur parent, puis relier la métatable à Cat. Redéfinissez la méthode :speak() afin que les chats disent quelque chose de différent : affichez le nom du chat suivi de meows: Meow!
Cow.lua : une autre classe enfant qui hérite de Animal. Configurez le constructeur de la même manière que pour Cat. Redéfinissez :speak() afin que les vaches affichent leur nom suivi de moos: Moo!
main.lua : rassemblez tout ! Lisez deux noms depuis l’entrée, créez un Cat avec le premier nom et un Cow avec le second, puis appelez :speak() sur chacun afin de montrer que le même nom de méthode produit une sortie différente selon la classe.

Vous recevrez deux entrées :

Le nom du chat
Le nom de la vache

Dans votre fichier principal, créez les deux animaux et appelez :speak() d’abord sur le chat, puis sur la vache.

Par exemple, si les entrées sont Whiskers et Bessie, la sortie doit être :

Whiskers meows: Meow!
Bessie moos: Moo!

Remarquez que les deux animaux répondent au même appel de méthode :speak(), mais que chacun produit une sortie propre à son type. La version de Cat remplace complètement le comportement générique de la classe parente, « makes a sound », et celle de Cow fait de même. C’est la redéfinition de méthode en action : la même interface, des implémentations différentes !

Essayez vous-même

-- main.lua : Rassembler le tout

local Cat = require('Cat')
local Cow = require('Cow')

-- Lire l'entrée
local catName = io.read()
local cowName = io.read()

-- TODO: Créer un Cat avec le premier nom

-- TODO: Créer un Cow avec le second nom

-- TODO: Appeler :speak() sur le chat d'abord, puis sur la vache