Niezależne instancje

Część sekcji Programowanie obiektowe ścieżki Lua w Coddy. Lekcja 10 z 70.

Kluczowym aspektem programowania obiektowego jest to, że każda instancja zachowuje własny, odrębny stan. Gdy utworzysz dwa obiekty z tej samej klasy, będą one całkowicie niezależne: zmiana jednego nie wpłynie na drugi.

Rozważmy ten przykład:

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

-- Utwórz dwa osobne liczniki
local counterA = Counter:new(10)
local counterB = Counter:new(5)

counterA:increment()
counterA:increment()

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

Mimo że oba liczniki pochodzą z tej samej klasy Counter, zwiększenie counterA nie ma wpływu na counterB. Każdy obiekt ma własne pole value przechowywane we własnej tabeli instancji.

Ta niezależność sprawia, że obiekty są przydatne. Możesz tworzyć w grze dziesiątki graczy, z których każdy śledzi własne zdrowie i wynik. Możesz zarządzać wieloma kontami bankowymi, z których każde ma inne saldo.

Klasa definiuje strukturę i zachowanie, ale każda instancja żyje własnym życiem i ma własne dane.

Wyzwanie

Łatwy

Udowodnijmy, że obiekty tej samej klasy naprawdę prowadzą niezależne życie! Zbudujesz klasę Wallet i utworzysz dwie osobne instancje portfela, a następnie zmodyfikujesz je niezależnie, aby pokazać, że zmiany w jednym nie wpływają na drugi.

Rozmieścisz swój kod w dwóch plikach:

Wallet.lua: Zdefiniuj klasę Wallet ze standardowym wzorcem konstruktora. Każdy portfel powinien śledzić własne balance. Uwzględnij:
- Konstruktor :new(startingBalance), który inicjalizuje portfel podaną kwotą
- Metodę :add(amount), która zwiększa saldo
- Metodę :spend(amount), która zmniejsza saldo
main.lua: Załaduj moduł Wallet i utwórz dwie osobne instancje portfela. Wykonaj na każdej inne operacje, aby pokazać, że zachowują niezależny stan.

Otrzymasz cztery dane wejściowe:

Saldo początkowe portfela A
Saldo początkowe portfela B
Kwota do dodania do portfela A
Kwota do wydania z portfela B

W pliku głównym:

Utwórz walletA z pierwszym saldem początkowym
Utwórz walletB z drugim saldem początkowym
Dodaj podaną kwotę do walletA
Wydaj podaną kwotę z walletB
Wypisz oba salda w osobnych wierszach

Wypisz końcowe salda dokładnie w tym formacie:

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

Na przykład, jeśli dane wejściowe to 100, 50, 25 i 10, wynikiem powinno być:

Wallet A: 125
Wallet B: 40

Zauważ, że dodanie środków do portfela A nie zmienia stanu portfela B, a wydanie środków z portfela B nie wpływa na portfel A: każda instancja zachowuje własne, oddzielne saldo.

Spróbuj swoich sił

-- Załaduj moduł Wallet
local Wallet = require('Wallet')

-- Odczytaj dane wejściowe
local startingA = tonumber(io.read())
local startingB = tonumber(io.read())
local addAmount = tonumber(io.read())
local spendAmount = tonumber(io.read())

-- TODO: Utwórz walletA z pierwszym saldem początkowym

-- TODO: Utwórz walletB z drugim saldem początkowym

-- TODO: Dodaj określoną kwotę do walletA

-- TODO: Wydaj określoną kwotę z walletB

-- TODO: Wypisz salda końcowe w wymaganym formacie
-- Format: "Wallet A: [balance]" i "Wallet B: [balance]"