Lua - Programmazione Orientata agli Oggetti

Introduzione alla POO

Ciao a tutti, aspiranti programmatori! Oggi ci imbarchiamo in un viaggio emozionante nel mondo della Programmazione Orientata agli Oggetti (POO) utilizzando Lua. Non preoccupatevi se siete nuovi alla programmazione; vi guiderò attraverso ogni passo con la stessa cura e entusiasmo che ho usato nelle mie lezioni per anni.

La Programmazione Orientata agli Oggetti è come costruire con i mattoncini LEGO. Ogni mattoncino (o oggetto) ha le sue propre proprietà e può fare determinate cose. Quando li uniamo, creiamo strutture straordinarie (o programmi)!

Caratteristiche della POO

Prima di immergerci in Lua, vediamo rapidamente le principali caratteristiche della POO:

1. Incapulamento: È come tenere i vostri giocattoli in una scatola. La scatola (oggetto) contiene tutte le cose correlate (dati e funzioni).
2. Eredità: Immaginate di avere un giocattolo robot. Ora, ricevete un nuovo giocattolo robot che può fare tutto quello che faceva il vecchio, più alcuni trucchetti nuovi. Questo è l'ereditarietà!
3. Polimorfismo: È come avere un telecomando che funziona per diversi dispositivi. Stesso pulsante, diverse azioni a seconda di cosa state controllando.
4. Astrazione: Pensate a usarne un microonde. Non è necessario sapere come funziona all'interno; è sufficiente sapere quali pulsanti premere.

POO in Lua

Ora, vediamo come possiamo utilizzare questi concetti POO in Lua. Lua non ha classi incorporate come alcune altre lingue, ma possiamo creare strutture orientate agli oggetti utilizzando tabelle e funzioni. È come costruire il nostro set LEGO da zero!

Creazione di una Classe Semplice

Iniziamo creando una classe semplice. In Lua, utilizziamo tabelle per rappresentare le classi.

local Dog = {}
Dog.__index = Dog

function Dog.new(name, age)
local self = setmetatable({}, Dog)
self.name = name
self.age = age
return self
end

function Dog:bark()
print(self.name .. " dice: Woof!")
end

Spieghiamo questo:

1. Creiamo una tabella chiamata Dog.
2. Impostiamo Dog.__index = Dog. Questo è un po' di magia Lua che aiuta con l'ereditarietà.
3. Creiamo una funzione new che funziona come il nostro costruttore. Crea un nuovo cane con un nome e un'età.
4. Aggiungiamo un metodo bark alla nostra classe Dog.

Creazione di un Oggetto

Ora che abbiamo la nostra classe Dog, creiamo un oggetto Dog:

local myDog = Dog.new("Buddy", 3)

Complimenti! Avete appena creato il vostro primo oggetto. myDog è ora un oggetto Dog con il nome "Buddy" e l'età 3.

Accesso alle Proprietà

Possiamo accedere alle proprietà del nostro cane così:

print(myDog.name) -- Output: Buddy
print(myDog.age)  -- Output: 3

È semplice come usare la notazione punto!

Accesso a una Funzione Membro

Per far abbaiare il nostro cane, possiamo chiamare il metodo bark:

myDog:bark() -- Output: Buddy dice: Woof!

Notate l'uso del due punti : invece di un punto. Questo è il modo di Lua per passare self al metodo.

Esempio Completo

Mettiamo tutto insieme:

local Dog = {}
Dog.__index = Dog

function Dog.new(name, age)
local self = setmetatable({}, Dog)
self.name = name
self.age = age
return self
end

function Dog:bark()
print(self.name .. " dice: Woof!")
end

local Labrador = {}
setmetatable(Labrador, {__index = Dog})

function Labrador.new(name, age, color)
local self = Dog.new(name, age)
setmetatable(self, {__index = Labrador})
self.color = color
return self
end

function Labrador:swim()
print(self.name .. " sta nuotando!")
end

Ecco, abbiamo creato una classe Labrador che eredita da Dog. Ha tutte le proprietà e i metodi di Dog, più una nuova proprietà (colore) e un nuovo metodo (nuota).

Sovrascrittura di Funzioni di Base

Possiamo anche sovrascrivere le funzioni della classe base. Diamo al nostro Labrador un abbaiare speciale:

function Labrador:bark()
print(self.name .. " dice: Woof woof woof!")
end

Ora, quando un Labrador abbaia, sarà diverso da un cane comune.

Esempio Completo di Eredità

Metto tutto insieme:

local Dog = {}
Dog.__index = Dog

function Dog.new(name, age)
local self = setmetatable({}, Dog)
self.name = name
self.age = age
return self
end

function Dog:bark()
print(self.name .. " dice: Woof!")
end

local Labrador = {}
setmetatable(Labrador, {__index = Dog})

function Labrador.new(name, age, color)
local self = Dog.new(name, age)
setmetatable(self, {__index = Labrador})
self.color = color
return self
end

function Labrador:swim()
print(self.name .. " sta nuotando!")
end

function Labrador:bark()
print(self.name .. " dice: Woof woof woof!")
end

local myDog = Dog.new("Buddy", 3)
local myLabrador = Labrador.new("Max", 2, "Giallo")

myDog:bark()      -- Output: Buddy dice: Woof!
myLabrador:bark() -- Output: Max dice: Woof woof woof!
myLabrador:swim() -- Output: Max sta nuotando!

Eccoci! Abbiamo creato una struttura di classe di base, implementato l'ereditarietà e persino sovrascritto metodi. Sei ben avviato per diventare un esperto di POO in Lua!

Ricorda, la pratica rende perfetti. Prova a creare le tue classi e sperimenta con diverse proprietà e metodi. Buon codice!

Credits: Image by storyset