Ajouter des méthodes enfants

Fait partie de la section Object Oriented Programming 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 la véritable puissance vient de l'ajout de nouvelles méthodes que seule l'enfant possède. Un Dog peut faire tout ce qu'un Animal peut faire, plus des choses uniques aux chiens, comme aboyer.

Ajouter une méthode spécifique à l'enfant est simple : il suffit de la définir sur 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 le parent.

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 les méthodes héritées et les méthodes uniques :

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Résultat : Buddy is breathing (héritée)
buddy:bark()     -- Résultat : Buddy says: Woof! (enfant uniquement)

La classe parente reste inchangée — appeler :bark() sur un Animal ordinaire échouerait car 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 en un seul 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 qui provient de Pet mais possède également une méthode unique que seuls les chats peuvent faire.

Vous organiserez votre code sur trois fichiers :

Pet.lua : Définissez votre classe parente avec un constructeur :new(name) qui stocke 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 votre Cat doit appeler le constructeur parent pour initialiser le nom, puis lier à nouveau 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 n'existe que dans Cat—Pet ne l'a pas !
main.lua : Importez votre module Cat, lisez un nom depuis l'entrée, créez une instance de Cat et dé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 devrait ê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 deuxième ligne provient de la méthode :purr() qui n'existe que dans Cat. Cela démontre comment les classes enfants peuvent faire tout ce que leur parent peut faire, plus leurs propres comportements spécialisés !

Aide-mémoire

Les classes enfants peuvent ajouter de nouvelles méthodes qui leur sont propres, tout en héritant de toutes les méthodes parentes. Les instances recherchent d'abord les méthodes dans leur propre classe, puis se rabattent sur le parent.

Pour ajouter une méthode spécifique à l'enfant, définissez-la sur la table de la classe enfant :

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 inherits from 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

-- Child-specific method
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Les instances enfants peuvent utiliser à la fois les méthodes héritées et les méthodes uniques :

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Inherited from Animal
buddy:bark()     -- Child-only method

La classe parente reste inchangée — elle n'a pas accès aux méthodes spécifiques à l'enfant.

Essayez vous-même

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

local Cat = require('Cat')

-- Lire le nom du chat à partir de 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 spécifique à Cat :purr()