Instancias independientes

Parte de la sección Programación Orientada a Objetos del Journey de Lua de Coddy. Lección 10 de 70.

Un aspecto crucial de la programación orientada a objetos es que cada instancia mantiene su propio estado independiente. Cuando creas dos objetos a partir de la misma clase, son completamente independientes: cambiar uno no afecta al otro.

Considera este ejemplo:

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

-- Crea dos contadores separados
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

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

Aunque ambos contadores provienen de la misma clase Counter, incrementar counterA no tiene ningún efecto en counterB. Cada objeto tiene su propio campo value almacenado en su propia tabla de instancia.

Esta independencia es lo que hace útiles a los objetos. Puedes crear docenas de jugadores en un juego, cada uno haciendo un seguimiento de su propia salud y puntuación. Puedes gestionar varias cuentas bancarias, cada una con un saldo diferente.

La clase define la estructura y el comportamiento, pero cada instancia vive su propia vida con sus propios datos.

Desafío

Fácil

¡Demostremos que los objetos de la misma clase realmente tienen vidas independientes! Crearás una clase Wallet y crearás dos instancias de billetera separadas; después, las modificarás de forma independiente para demostrar que los cambios en una no afectan a la otra.

Organizarás tu código en dos archivos:

Wallet.lua: Define tu clase Wallet con el patrón de constructor estándar. Cada billetera debe llevar su propio registro de balance. Incluye:
- Un constructor :new(startingBalance) que inicialice la billetera con la cantidad indicada
- Un método :add(amount) que aumente el saldo
- Un método :spend(amount) que reduzca el saldo
main.lua: Requiere tu módulo Wallet y crea dos instancias de billetera separadas. Realiza operaciones diferentes en cada una para demostrar que mantienen un estado independiente.

Recibirás cuatro entradas:

Saldo inicial de la billetera A
Saldo inicial de la billetera B
Cantidad que se añadirá a la billetera A
Cantidad que se gastará de la billetera B

En tu archivo principal:

Crea walletA con el primer saldo inicial
Crea walletB con el segundo saldo inicial
Añade la cantidad indicada a walletA
Gasta la cantidad indicada de walletB
Imprime ambos saldos en líneas separadas

Imprime los saldos finales exactamente con este formato:

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

Por ejemplo, si las entradas son 100, 50, 25 y 10, la salida debería ser:

Wallet A: 125
Wallet B: 40

Observa que añadir dinero a la billetera A no cambia la billetera B, y gastar dinero de la billetera B no afecta a la billetera A: cada instancia mantiene su propio saldo independiente.

Pruébalo tú mismo

-- Requiere el módulo Wallet
local Wallet = require('Wallet')

-- Lee las entradas
local startingA = tonumber(io.read())
local startingB = tonumber(io.read())
local addAmount = tonumber(io.read())
local spendAmount = tonumber(io.read())

-- TODO: Crea walletA con el primer saldo inicial

-- TODO: Crea walletB con el segundo saldo inicial

-- TODO: Añade la cantidad especificada a walletA

-- TODO: Gasta la cantidad especificada de walletB

-- TODO: Imprime los saldos finales en el formato requerido
-- Formato: "Wallet A: [balance]" y "Wallet B: [balance]"