Instances indépendantes

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

Un aspect crucial de la programmation orientée objet est que chaque instance conserve son propre état distinct. Lorsque vous créez deux objets à partir de la même classe, ils sont complètement indépendants — modifier l'un n'affecte pas l'autre.

Considérez cet exemple :

local Counter = {}
Counter.__index = Counter

function Counter:new(start)
    local instance = {}
    setmetatable(instance, self)
    instance.value = start or 0
    return instance
end

function Counter:increment()
    self.value = self.value + 1
end

-- Créer deux compteurs distincts
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

print(counterA.value)  -- Résultat : 12
print(counterB.value)  -- Résultat : 5

Même si les deux compteurs proviennent de la même classe Counter, incrémenter counterA n'a aucun effet sur counterB. Chaque objet possède son propre champ value stocké dans sa propre table d'instance.

Cette indépendance est ce qui rend les objets utiles. Vous pouvez créer des dizaines de joueurs dans un jeu, chacun suivant sa propre santé et son propre score. Vous pouvez gérer plusieurs comptes bancaires, chacun avec un solde différent.

La classe définit la structure et le comportement, mais chaque instance mène sa propre vie avec ses propres données.

Défi

Facile

Prouvons que les objets d'une même classe mènent véritablement des vies indépendantes ! Vous allez construire une classe Wallet et créer deux instances de portefeuille distinctes, puis les modifier indépendamment pour démontrer que les changements apportés à l'une n'affectent pas l'autre.

Vous organiserez votre code sur deux fichiers :

Wallet.lua : Définissez votre classe Wallet avec le modèle de constructeur standard. Chaque portefeuille doit suivre son propre balance. Incluez :
- Un constructeur :new(startingBalance) qui initialise le portefeuille avec le montant donné
- Une méthode :add(amount) qui augmente le solde
- Une méthode :spend(amount) qui diminue le solde
main.lua : Importez votre module Wallet et créez deux instances de portefeuille distinctes. Effectuez différentes opérations sur chacune pour montrer qu'elles conservent un état indépendant.

Vous recevrez quatre entrées :

Solde de départ pour le portefeuille A
Solde de départ pour le portefeuille B
Montant à ajouter au portefeuille A
Montant à dépenser du portefeuille B

Dans votre fichier principal :

Créez walletA avec le premier solde de départ
Créez walletB avec le second solde de départ
Ajoutez le montant spécifié à walletA
Dépensez le montant spécifié de walletB
Affichez les deux soldes sur des lignes séparées

Affichez les soldes finaux dans ce format exact :

Wallet A: [balance]
Wallet B: [balance]

Par exemple, si les entrées sont 100, 50, 25, et 10, la sortie devrait être :

Wallet A: 125
Wallet B: 40

Remarquez comment l'ajout au portefeuille A ne modifie pas le portefeuille B, et comment dépenser du portefeuille B n'affecte pas le portefeuille A — chaque instance conserve son propre solde distinct.

Aide-mémoire

Chaque instance d'une classe maintient son propre état distinct. Créer plusieurs objets à partir de la même classe produit des instances complètement indépendantes — en modifier une n'affecte pas les autres.

Exemple illustrant l'indépendance des instances :

local Counter = {}
Counter.__index = Counter

function Counter:new(start)
    local instance = {}
    setmetatable(instance, self)
    instance.value = start or 0
    return instance
end

function Counter:increment()
    self.value = self.value + 1
end

-- Créer deux compteurs distincts
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

print(counterA.value)  -- Résultat : 12
print(counterB.value)  -- Résultat : 5

Chaque objet possède sa propre table d'instance stockant ses propres données. La classe définit la structure et le comportement, mais chaque instance maintient un état indépendant.

Essayez vous-même

-- Requiert le module Wallet
local Wallet = require('Wallet')

-- Lire les entrées
local startingA = tonumber(io.read())
local startingB = tonumber(io.read())
local addAmount = tonumber(io.read())
local spendAmount = tonumber(io.read())

-- TODO: Créer walletA avec le premier solde de départ

-- TODO: Créer walletB avec le second solde de départ

-- TODO: Ajouter le montant spécifié à walletA

-- TODO: Dépenser le montant spécifié de walletB

-- TODO: Afficher les soldes finaux au format requis
-- Format: "Wallet A: [balance]" et "Wallet B: [balance]"