Lua Academy · Lezione

Ereditarietà multilivello

Supporti catene di ereditarietà profonde con una corretta delega di __index.

Ereditarietà multilivello è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Ripasso dell'ereditarietà singola

L'ereditarietà singola si ottiene impostando Child.__index = Parent. Ricerca dei metodi: se il metodo non è presente in Child, viene cercato in Parent tramite __index.

Estensione della factory per le classi con l'ereditarietà

Aggiunga un metodo :extend() alla classe base, che crea una sottoclasse collegata alla classe padre.

function Animal:extend()
  local cls = {}
  cls.__index = cls
  setmetatable(cls, {__index = self})
  cls.super = self
  function cls:new(...)
    local inst = setmetatable({}, cls)
    if inst.init then inst:init(...) end
    return inst
  end
  return cls
end

Creazione di una sottoclasse

Crei Dog come sottoclasse di Animal, eseguendo l'override di init e aggiungendo nuovi metodi.

local Dog = Animal:extend()
function Dog:init(name)
  Dog.super.init(self, name, "Woof")
  self.tricks = {}
end
function Dog:learnTrick(trick)
  self.tricks[#self.tricks+1] = trick
end
local d = Dog:new("Rex")
d:learnTrick("sit")
d:speak()  -- Rex says Woof

Catena a più livelli

Estenda Dog per creare GuideDog — una catena di ereditarietà a tre livelli.

local GuideDog = Dog:extend()
function GuideDog:init(name, owner)
  GuideDog.super.init(self, name)
  self.owner = owner
end
function GuideDog:guide()
  print(self.name .. " guides " .. self.owner)
end

Chiamata dei metodi super

Chiami sempre super tramite il riferimento alla classe, non tramite self, per evitare la ricorsione infinita.

function Dog:init(name)
  Dog.super.init(self, name, "Woof")  -- explicit super call
end

Ordine di risoluzione dei metodi

Lua risolve i metodi dal basso verso l'alto attraverso le catene di __index. GuideDog → Dog → Animal → nil. Vince il primo metodo trovato.

Override dei metodi

Definisca nella sottoclasse un metodo con lo stesso nome per eseguire l'override. Chiami esplicitamente super per gli override parziali.

function Dog:speak()
  print(self.name .. " barks!")
  Dog.super.speak(self)  -- also call parent speak
end

Limiti di profondità

Catene di ereditarietà molto profonde rallentano la ricerca dei metodi (ogni livello aggiunge un passaggio __index). Preferisca la composizione oltre i 3-4 livelli.

Verifica dell'appartenenza a una classe

Percorra la catena delle metatabelle per verificare se un'istanza appartiene a una classe.

local function isA(instance, cls)
  local mt = getmetatable(instance)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end
print(isA(d, Dog))     -- true
print(isA(d, Animal))  -- true

Copia profonda con conservazione della classe

Quando esegue una copia profonda delle istanze, conservi la metatabella in modo che la copia rimanga un'istanza della classe corretta.

Quando preferire la composizione

Utilizzi l'ereditarietà per le vere relazioni is-a (Dog is-a Animal). Utilizzi la composizione (tabelle di componenti) per le relazioni has-a o per combinare comportamenti in modo flessibile.

Domanda sull'ereditarietà

Come funziona l'ereditarietà a più livelli in Lua?

Riepilogo: ereditarietà a più livelli

Estenda la factory per le classi con un metodo :extend() che concatena i collegamenti __index. Chiami super esplicitamente con ClassName.super.method(self, ...). Verifichi l'appartenenza percorrendo la catena delle metatabelle.

Domande Frequenti

La lezione «Ereditarietà multilivello» è gratuita?

Sì — il testo completo di «Ereditarietà multilivello» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Ereditarietà multilivello»?

Supporti catene di ereditarietà profonde con una corretta delega di __index. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Ereditarietà multilivello»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Progettazione della classe base e del costruttore
Ereditarietà multilivello
Composizione dei mixin e verifica delle interfacce
instanceof e introspezione dei tipi

← Torna a Lua Academy