Aggiungere metodi alla classe figlia

Fa parte della sezione Programmazione orientata agli oggetti del percorso Lua di Coddy. Lezione 34 di 70.

L'ereditarietà consente alle classi figlie di accedere ai metodi delle classi genitrici, ma il vero potenziale emerge aggiungendo nuovi metodi che solo la classe figlia possiede. Un Dog può fare tutto ciò che può fare un Animal, oltre a cose tipiche dei cani, come abbaiare.

Aggiungere un metodo specifico della classe figlia è semplice: basta definirlo nella tabella della classe figlia. Poiché le istanze cercano prima i metodi nella propria classe, troveranno il nuovo metodo senza influire sulla classe genitore.

local Animal = {}
Animal.__index = Animal

function Animal:new(name)
    local obj = {name = name}
    setmetatable(obj, Animal)
    return obj
end

function Animal:breathe()
    print(self.name .. " is breathing")
end

-- Dog eredita da Animal
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

function Dog:new(name)
    local obj = Animal.new(Animal, name)
    setmetatable(obj, Dog)
    return obj
end

-- Nuovo metodo presente solo in Dog
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Ora le istanze di Dog possono usare sia i metodi ereditati sia quelli specifici:

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Output: Buddy is breathing (ereditato)
buddy:bark()     -- Output: Buddy says: Woof! (solo della classe figlia)

La classe genitore rimane invariata: chiamare :bark() su un Animal semplice causerebbe un errore, perché quel metodo non esiste nella classe. È così che l’ereditarietà ti permette di specializzare il comportamento mantenendo le funzionalità condivise in un unico posto.

Sfida

Facile

Costruiamo una gerarchia di animali domestici in cui i gatti hanno una capacità speciale tutta loro! Creerai una classe genitore Pet e una classe figlia Cat, in cui Cat eredita tutto da Pet, ma ha anche un metodo unico che solo i gatti possono eseguire.

Organizzerai il codice in tre file:

Pet.lua: Definisci la classe genitore con un costruttore :new(name) che memorizza il nome dell'animale domestico. Includi un metodo :greet() che stampa il nome dell'animale domestico seguito da says hello. Imposta il modello standard di classe e restituisci la classe.
Cat.lua: Definisci la classe figlia che eredita da Pet. Il costruttore :new(name) di Cat dovrebbe chiamare il costruttore genitore per inizializzare il nome, quindi ricollegare la metatabella a Cat. Aggiungi un metodo :purr() specifico della classe figlia che stampa il nome del gatto seguito da purrs contentedly. Questo metodo esiste solo in Cat: Pet non ce l'ha!
main.lua: Importa il modulo Cat, leggi un nome dall'input, crea un'istanza di Cat e dimostra che può usare sia il metodo ereditato :greet() sia il suo metodo esclusivo :purr().

Riceverai un input: il nome del gatto.

Nel tuo file principale, crea un Cat con il nome fornito, quindi chiama :greet() seguito da :purr() su righe separate.

Per esempio, se l'input è Whiskers, l'output dovrebbe essere:

Whiskers says hello
Whiskers purrs contentedly

La prima riga proviene dal metodo ereditato :greet() definito in Pet, mentre la seconda riga proviene dal metodo :purr(), che esiste solo in Cat. Questo dimostra come le classi figlie possano fare tutto ciò che può fare la classe genitore, oltre ad avere i propri comportamenti specializzati!

Provalo tu

-- main.lua: crea un Cat e dimostra l'ereditarietà

local Cat = require('Cat')

-- Leggi il nome del gatto dall'input
local name = io.read()

-- TODO: crea un'istanza di Cat con il nome fornito

-- TODO: chiama il metodo ereditato :greet() (da Pet)

-- TODO: chiama il metodo :purr() specifico di Cat