Instances indépendantes

Fait partie de la section Programmation orientée objet 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 séparé. 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 séparés
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

print(counterA.value)  -- Sortie : 12
print(counterB.value)  -- Sortie : 5

Bien que 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 ses propres points de vie et son 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 vit sa propre vie avec ses propres données.

Défi

Facile

Montrons que les objets d'une même classe vivent véritablement de manière indépendante ! Vous allez créer une classe Wallet et deux instances distinctes de portefeuille, puis les modifier indépendamment afin de démontrer que les changements apportés à l'un n'affectent pas l'autre.

Vous allez organiser 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 distinctes de portefeuille. Effectuez des opérations différentes sur chacune pour montrer qu'elles conservent un état indépendant.

Vous recevrez quatre entrées :

Solde initial du portefeuille A
Solde initial du portefeuille B
Montant à ajouter au portefeuille A
Montant à dépenser du portefeuille B

Dans votre fichier principal :

Créez walletA avec le premier solde initial
Créez walletB avec le deuxième solde initial
Ajoutez le montant indiqué à walletA
Dépensez le montant indiqué de walletB
Affichez les deux soldes sur des lignes distinctes

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 doit être :

Wallet A: 125
Wallet B: 40

Remarquez que l'ajout au portefeuille A ne modifie pas le portefeuille B et que les dépenses du portefeuille B n'affectent pas le portefeuille A : chaque instance conserve son propre solde distinct.

Essayez vous-même

-- Charger 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 dans le format requis
-- Format : "Wallet A: [balance]" et "Wallet B: [balance]"