Chiamare i metodi della classe genitore

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

A volte sovrascrivere completamente un metodo non è ciò che vuoi. Potresti invece voler estendere il comportamento della classe genitore: fare ciò che fa la classe genitore e poi aggiungere qualcosa in più. Per riuscirci, puoi chiamare direttamente il metodo della classe genitore all'interno del metodo sovrascritto della classe figlia.

La tecnica usa la sintassi con il punto con il nome della classe padre, passando esplicitamente self come primo argomento:

local Animal = {}
Animal.__index = Animal

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

function Animal:speak()
    print(self.name .. " makes a sound")
end

-- Dog estende il comportamento della classe padre
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

function Dog:speak()
    Animal.speak(self)  -- Chiama prima il metodo della classe padre
    print(self.name .. " wags tail happily")
end

La riga chiave è Animal.speak(self). Usando la sintassi del punto sulla classe genitore e passando manualmente self, invochiamo il metodo originale prima di aggiungere il nostro comportamento:

local buddy = Dog:new("Buddy")
buddy:speak()
-- Output:
-- Buddy emette un suono
-- Buddy scodinzola felice

Questo schema è utile quando il metodo della classe genitore svolge un lavoro importante che non vuoi duplicare. La classe figlia può eseguire la logica della classe genitore prima, dopo o persino nel mezzo del proprio codice, dandoti il pieno controllo su come combinare i comportamenti.

Sfida

Facile

Costruiamo un sistema di saluti in cui una FormalPerson estende il comportamento di una normale Person! Invece di sostituire completamente il modo in cui una persona si presenta, la versione formale eseguirà prima la presentazione standard, poi aggiungerà un tocco di cortesia.

Organizzerai il codice in tre file:

Person.lua: la tua classe base con un costruttore :new(name) che memorizza il nome della persona. Includi un metodo :introduce() che stampa il nome della persona seguito da says hi. Questo è il comportamento di base che verrà esteso.
FormalPerson.lua: una classe figlia che eredita da Person. Il suo costruttore dovrebbe chiamare il costruttore della classe genitore per gestire il nome. Sovrascrivi il metodo :introduce(), ma invece di sostituire interamente il comportamento della classe genitore, chiama prima il metodo della classe genitore usando Person.introduce(self), poi stampa una riga aggiuntiva con il nome della persona seguito da bows politely.
main.lua: importa il modulo FormalPerson, legge un nome dall'input, crea un'istanza di FormalPerson e chiama :introduce() per vedere combinati entrambi i comportamenti.

Riceverai un input: il nome della persona.

Quando chiami :introduce() su una FormalPerson, dovrebbe produrre due righe di output: la prima dal metodo della classe genitore, la seconda aggiunta dalla classe figlia:

{name} says hi
{name} bows politely

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

Eleanor says hi
Eleanor bows politely

L'intuizione fondamentale è che FormalPerson non duplica la logica di "says hi". Delega quel compito al metodo della classe genitore, poi aggiunge il proprio comportamento distintivo. In questo modo il codice rimane pulito e mostri come le classi figlie possano estendere, anziché sostituire, le funzionalità della classe genitore!

Provalo tu

-- main.lua: Punto di ingresso per il sistema di saluto

local FormalPerson = require('FormalPerson')

-- Leggi il nome della persona dall'input
local name = io.read()

-- TODO: Crea un'istanza di FormalPerson con il nome fornito

-- TODO: Chiama il metodo introduce sull'istanza di FormalPerson