Ajouter des méthodes enfants

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

L’héritage permet aux classes enfants d’accéder aux méthodes parentes, mais sa véritable puissance vient de l’ajout de nouvelles méthodes que seule la classe enfant possède. Un Dog peut faire tout ce qu’un Animal peut faire, ainsi que des choses propres aux chiens, comme aboyer.

Ajouter une méthode spécifique à l’enfant est simple : il suffit de la définir dans la table de la classe enfant. Comme les instances recherchent d’abord les méthodes dans leur propre classe, elles trouveront la nouvelle méthode sans affecter la classe parente.

local Animal = {}
Animal.__index = Animal

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

function Animal:breathe()
    print(self.name .. " is breathing")
end

-- Dog hérite de Animal
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

-- Nouvelle méthode uniquement dans Dog
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Désormais, les instances de Dog peuvent utiliser à la fois des méthodes héritées et des méthodes qui leur sont propres :

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Sortie : Buddy respire (hérité)
buddy:bark()     -- Sortie : Buddy dit : Woof ! (enfant uniquement)

La classe parent reste inchangée : appeler :bark() sur un Animal ordinaire échouerait puisque cette méthode n’y existe pas. C’est ainsi que l’héritage vous permet de spécialiser le comportement tout en conservant les fonctionnalités partagées au même endroit.

Défi

Facile

Construisons une hiérarchie d’animaux de compagnie où les chats ont leur propre capacité spéciale ! Vous allez créer une classe parente Pet et une classe enfant Cat, où Cat hérite de tout ce que contient Pet, mais possède également une méthode unique que seuls les chats peuvent utiliser.

Vous allez organiser votre code dans trois fichiers :

Pet.lua : définissez votre classe parente avec un constructeur :new(name) qui mémorise le nom de l’animal. Incluez une méthode :greet() qui affiche le nom de l’animal suivi de says hello. Mettez en place le modèle de classe standard et retournez la classe.
Cat.lua : définissez votre classe enfant qui hérite de Pet. Le constructeur :new(name) de Cat doit appeler le constructeur parent pour initialiser le nom, puis réassocier la métatable à Cat. Ajoutez une méthode :purr() spécifique à l’enfant qui affiche le nom du chat suivi de purrs contentedly. Cette méthode existe uniquement dans Cat : Pet ne la possède pas !
main.lua : exigez votre module Cat, lisez un nom depuis l’entrée, créez une instance de Cat et montrez qu’elle peut utiliser à la fois la méthode héritée :greet() et sa propre méthode unique :purr().

Vous recevrez une entrée : le nom du chat.

Dans votre fichier principal, créez un Cat avec le nom donné, puis appelez :greet() suivi de :purr() sur des lignes séparées.

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

Whiskers says hello
Whiskers purrs contentedly

La première ligne provient de la méthode héritée :greet() définie dans Pet, tandis que la seconde ligne provient de la méthode :purr() qui existe uniquement dans Cat. Cela montre comment les classes enfants peuvent faire tout ce que leur parent peut faire, en plus de leurs propres comportements spécialisés !

Essayez vous-même

-- main.lua: Créer un Cat et démontrer l'héritage

local Cat = require('Cat')

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

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

-- TODO: Appeler la méthode héritée :greet() (de Pet)

-- TODO: Appeler la méthode :purr() spécifique à Cat