Instâncias Independentes

Parte da seção Programação Orientada a Objetos do Journey de Lua da Coddy. Lição 10 de 70.

Um aspecto crucial da programação orientada a objetos é que cada instância mantém seu próprio estado separado. Quando você cria dois objetos a partir da mesma classe, eles são completamente independentes: alterar um não afeta o outro.

Considere este exemplo:

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

-- Cria dois contadores separados
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

print(counterA.value)  -- Saída: 12
print(counterB.value)  -- Saída: 5

Embora ambos os contadores venham da mesma classe Counter, incrementar counterA não tem efeito sobre counterB. Cada objeto tem seu próprio campo value armazenado em sua própria tabela de instância.

Essa independência é o que torna os objetos úteis. Você pode criar dezenas de jogadores em um jogo, cada um acompanhando sua própria saúde e pontuação. Você pode gerenciar várias contas bancárias, cada uma com um saldo diferente.

A classe define a estrutura e o comportamento, mas cada instância vive sua própria vida com seus próprios dados.

Desafio

Fácil

Vamos provar que os objetos da mesma classe realmente vivem vidas independentes! Você criará uma classe Wallet e duas instâncias separadas de carteira, depois as modificará independentemente para demonstrar que as alterações em uma não afetam a outra.

Você organizará seu código em dois arquivos:

Wallet.lua: defina sua classe Wallet com o padrão de construtor usual. Cada carteira deve controlar seu próprio balance. Inclua:
- Um construtor :new(startingBalance) que inicializa a carteira com o valor fornecido
- Um método :add(amount) que aumenta o saldo
- Um método :spend(amount) que diminui o saldo
main.lua: exija seu módulo Wallet e crie duas instâncias separadas de carteira. Realize operações diferentes em cada uma para mostrar que elas mantêm estados independentes.

Você receberá quatro entradas:

Saldo inicial da carteira A
Saldo inicial da carteira B
Valor a adicionar à carteira A
Valor a gastar da carteira B

No seu arquivo principal:

Crie walletA com o primeiro saldo inicial
Crie walletB com o segundo saldo inicial
Adicione o valor especificado a walletA
Gaste o valor especificado de walletB
Imprima os dois saldos em linhas separadas

Imprima os saldos finais exatamente neste formato:

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

Por exemplo, se as entradas forem 100, 50, 25 e 10, a saída deverá ser:

Wallet A: 125
Wallet B: 40

Observe como adicionar à carteira A não altera a carteira B, e gastar da carteira B não afeta a carteira A: cada instância mantém seu próprio saldo separado.

Experimente você mesmo

-- Requer o módulo Wallet
local Wallet = require('Wallet')

-- Lê as entradas
local startingA = tonumber(io.read())
local startingB = tonumber(io.read())
local addAmount = tonumber(io.read())
local spendAmount = tonumber(io.read())

-- TODO: Crie walletA com o primeiro saldo inicial

-- TODO: Crie walletB com o segundo saldo inicial

-- TODO: Adicione o valor especificado a walletA

-- TODO: Gaste o valor especificado de walletB

-- TODO: Imprima os saldos finais no formato exigido
-- Formato: "Wallet A: [balance]" e "Wallet B: [balance]"