Fonctions Factory

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

Tout au long de ce cours, vous avez créé des objets en appelant directement des constructeurs : Circle:new(), Rectangle:new(), et ainsi de suite. Mais que faire si vous souhaitez créer différents types d’objets en fonction d’une condition, sans que le code appelant ait besoin de savoir quelle classe spécifique utiliser ?

C’est là qu’intervient le pattern Factory. Une factory est simplement une fonction qui crée et renvoie des objets. Le principal avantage est que l’appelant n’a pas besoin de connaître les détails de la création de l’objet. Il demande simplement à la factory ce dont il a besoin.

local function createShape(shapeType)
    if shapeType == "circle" then
        return Circle:new(10)
    elseif shapeType == "square" then
        return Square:new(5)
    end
end

-- L'appelant n'a pas besoin de connaître les classes Circle ou Square
local myShape = createShape("circle")
print(myShape:area())

La fonction factory prend un argument de type chaîne et décide quelle classe instancier. Cela centralise la logique de création des objets en un seul endroit. Si vous ajoutez ultérieurement un nouveau type de forme, vous ne modifiez que la factory, et non chaque partie du code qui crée des formes.

Les fabriques sont particulièrement utiles lorsque la création d’un objet implique une configuration complexe, lorsque vous souhaitez masquer les détails d’implémentation ou lorsque le type exact de l’objet dépend de conditions d’exécution telles que la saisie de l’utilisateur ou les fichiers de configuration.

Défi

Facile

Construisons une fabrique d'animaux de compagnie ! Au lieu de créer directement les animaux en appelant le constructeur de chaque classe, vous allez créer une fonction de fabrique qui produit le type d'animal approprié à partir d'un simple argument chaîne.

Vous allez organiser votre code sur quatre fichiers :

Dog.lua : créez une classe Dog avec un constructeur :new(name) qui stocke le nom de l'animal. Ajoutez une méthode :speak() qui renvoie la chaîne "{name} says: Woof!" (où {name} est le nom du chien).
Cat.lua : créez une classe Cat avec la même structure : un constructeur :new(name) et une méthode :speak() qui renvoie "{name} says: Meow!".
PetFactory.lua : c'est ici que le patron Factory révèle tout son intérêt ! Créez une fonction createPet(petType, name) qui accepte deux arguments : une chaîne indiquant le type d'animal ("dog" ou "cat") et le nom de l'animal. La fonction doit renvoyer l'objet animal approprié. Si le type est "dog", renvoyez un nouveau Dog ; s'il est "cat", renvoyez un nouveau Cat.
main.lua : importez votre module PetFactory. Lisez deux entrées : le type d'animal et le nom de l'animal. Utilisez votre fonction de fabrique pour créer l'animal, puis appelez sa méthode :speak() et affichez le résultat.

L'intérêt du patron Factory est que votre code principal n'a pas besoin d'importer directement Dog ou Cat. Il ne connaît que la fabrique. La fabrique gère tous les détails concernant la classe à instancier.

Vous recevrez deux entrées :

Type d'animal (soit "dog", soit "cat")
Nom de l'animal (une chaîne)

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

Buddy says: Woof!

Si les entrées sont cat et Whiskers, la sortie doit être :

Whiskers says: Meow!

Essayez vous-même

-- main.lua
-- Utiliser le PetFactory pour créer des animaux de compagnie

local PetFactory = require('PetFactory')

-- Lire les entrées
local petType = io.read()
local petName = io.read()

-- TODO: Utiliser PetFactory.createPet pour créer le pet
-- TODO: Appeler la méthode :speak() du pet et afficher le résultat