Fonctions Factory

Fait partie de la section Object Oriented Programming 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 se passe-t-il si vous voulez créer différents types d'objets en fonction d'une certaine condition, sans que le code appelant n'ait besoin de savoir quelle classe spécifique utiliser ?

C'est ici que le pattern Factory intervient. Une factory est simplement une fonction qui crée et retourne des objets. L'avantage clé est que l'appelant n'a pas besoin de connaître les détails de la création d'objets — 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 de caractères et décide quelle classe instancier. Cela centralise la logique de création d'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'objets implique une configuration complexe, lorsque vous souhaitez masquer les détails d'implémentation, ou lorsque le type exact d'objet dépend de conditions d'exécution telles que la saisie de l'utilisateur ou des fichiers de configuration.

Défi

Facile

Construisons une fabrique d'animaux de compagnie (Pet Factory) ! Au lieu de créer des animaux directement en appelant le constructeur de chaque classe, vous allez créer une fonction "factory" qui produit le bon type d'animal en fonction d'un simple argument sous forme de chaîne de caractères.

Vous organiserez 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 retourne 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 retourne "{name} says: Meow!".
PetFactory.lua : C'est ici que le pattern Factory prend tout son sens ! Créez une fonction createPet(petType, name) qui prend deux arguments : une chaîne indiquant le type d'animal ("dog" ou "cat") et le nom de l'animal. La fonction doit retourner l'objet animal approprié. Si le type est "dog", retournez un nouveau Dog ; si c'est "cat", retournez 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 factory pour créer l'animal, puis appelez sa méthode :speak() et affichez le résultat.

La beauté du pattern Factory est que votre code principal n'a pas besoin d'importer Dog ou Cat directement — il ne connaît que la fabrique. La fabrique gère tous les détails de la classe à instancier.

Vous recevrez deux entrées :

Le type d'animal (soit "dog" soit "cat")
Le nom de l'animal (une chaîne de caractères)

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

Buddy says: Woof!

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

Whiskers says: Meow!

Aide-mémoire

Le pattern Factory (ou patron de fabrique) est un patron de conception où une fonction crée et retourne des objets en fonction de paramètres donnés. L'appelant n'a pas besoin de savoir quelle classe spécifique est instanciée — la fabrique se charge de cette décision.

Une fonction de fabrique centralise la logique de création d'objets :

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

local myShape = createShape("circle")
print(myShape:area())

Avantages du pattern Factory :

Masque les détails d'implémentation pour l'appelant
Centralise la création d'objets en un seul endroit
Facilite l'ajout de nouveaux types — seule la fabrique doit être modifiée
Utile lorsque le type d'objet dépend de conditions d'exécution (entrée utilisateur, configuration, etc.)
Utile lorsque la création d'objets implique une configuration complexe

Essayez vous-même

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

local PetFactory = require('PetFactory')

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

-- À FAIRE : Utiliser PetFactory.createPet pour créer l'animal
-- À FAIRE : Appeler la méthode :speak() de l'animal et afficher le résultat