Le constructeur :new()

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

Créer des objets manuellement — créer une table vide, définir sa métatable, lier __index — devient répétitif. La solution standard consiste à définir une méthode constructeur :new() directement dans la classe qui gère tout cela pour vous.

Voici le modèle :

local Dog = {}
Dog.__index = Dog

function Dog:new()
    local instance = {}
    setmetatable(instance, self)
    return instance
end

function Dog:bark()
    print("Woof!")
end

Analysons ce qui se passe à l'intérieur de :new(). Tout d'abord, nous créons une table vide nommée instance. Ensuite, nous définissons sa métatable sur self — qui est Dog lorsque nous appelons Dog:new().

Puisque Dog.__index pointe vers Dog lui-même, l'instance peut trouver toutes les méthodes définies dans Dog. Enfin, nous retournons le nouvel objet.

Remarquez la ligne Dog.__index = Dog à l'extérieur du constructeur. C'est un raccourci courant : au lieu de créer une métatable séparée, la table de classe sert à la fois de prototype et de métatable.

Désormais, la création d'objets est propre et cohérente :

local myDog = Dog:new()
myDog:bark()  -- Sortie : Woof !

Chaque classe que vous créez suivra cette même structure. Le constructeur :new() devient l'endroit unique où la création d'objets se produit, rendant votre code organisé et prévisible.

Défi

Facile

Construisons une classe Cat en utilisant le modèle de constructeur standard que vous venez d'apprendre. Vous organiserez votre code sur deux fichiers pour pratiquer une structure de module appropriée.

Vous allez créer :

Cat.lua : Définissez votre classe Cat avec le modèle de constructeur complet. Votre classe doit inclure :
- La table de classe avec __index pointant vers elle-même
- Un constructeur :new() qui crée une instance, définit sa métatable et la renvoie
- Une méthode :meow() qui affiche le cri du chat
Renvoyez la table de classe à la fin du fichier.
main.lua : Importez votre module Cat avec require et utilisez le constructeur pour créer une instance de chat. Ensuite, appelez sa méthode pour vérifier que tout est correctement lié.

Vous recevrez une entrée : le nombre de fois que votre chat doit miauler.

Votre méthode :meow() doit afficher exactement :

Meow!

Dans votre fichier principal, créez un chat en utilisant Cat:new() et appelez :meow() le nombre de fois spécifié.

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

Meow!
Meow!
Meow!

Aide-mémoire

Pour créer une classe avec un constructeur en Lua, définissez une méthode :new() qui crée des instances :

local ClassName = {}
ClassName.__index = ClassName

function ClassName:new()
    local instance = {}
    setmetatable(instance, self)
    return instance
end

function ClassName:method()
    -- method implementation
end

Le champ __index pointe vers la classe elle-même, permettant aux instances d'accéder aux méthodes définies dans la table de la classe.

À l'intérieur de :new() :

Créez une table vide pour l'instance
Définissez son métatable sur self (la classe)
Retournez la nouvelle instance

Créez des objets en utilisant le constructeur :

local obj = ClassName:new()
obj:method()

Essayez vous-même

-- Charger le module Cat
local Cat = require('Cat')

-- Lire l'entrée : nombre de fois à miauler
local times = tonumber(io.read())

-- À FAIRE : Créer une instance de chat en utilisant Cat:new()

-- À FAIRE : Appeler la méthode :meow() le nombre de fois spécifié