Lua Academy · Les

Oudermethoden aanroepen met super

Roep methoden van de basisklasse expliciet aan voor coöperatieve initialisatie

Les 2 van 412 stappen

Oudermethoden aanroepen met super is een gratis Lua Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Waarom superaanroepen?

Wanneer een kind een methode van de ouder overschrijft maar de logica van de ouder nog nodig heeft, roept het de methode van de ouder expliciet aan. Lua heeft geen sleutelwoord super — verwijs rechtstreeks naar de tabel van de ouder: Parent.method(self, args).

local Base={}
Base.__index=Base
function Base:describe()
  return "Base[name="..self.name.."]"
end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})

function Child:describe()
  local parentDesc = Base.describe(self)  -- super call
  return parentDesc .. " + Child[extra=true]"
end

local c=setmetatable({name="X"},Child)
print(c:describe())

Super in de constructor

Constructors van kinderen roepen constructors van de ouder aan via Parent.new() of Parent._init(self,...). Zo wordt de initialisatie van de ouder voor elke instantie van het kind uitgevoerd.

local Animal={}
Animal.__index=Animal
function Animal._init(self,name,sound)
  self.name=name; self.sound=sound; self.alive=true
end

local Dog={}
Dog.__index=Dog; setmetatable(Dog,{__index=Animal})
function Dog.new(name,breed)
  local self=setmetatable({},Dog)
  Animal._init(self,name,"Woof")  -- super init
  self.breed=breed
  return self
end

local d=Dog.new("Rex","Lab")
print(d.name,d.sound,d.breed)

Coöperatieve initialisatie

In diepe hiërarchieën initialiseert elk niveau alleen zijn eigen velden en roept het de initialisatie van de ouder aan. Zo blijft elke klasse alleen verantwoordelijk voor haar eigen velden.

local A={}
function A._init(self,x) self.x=x end

local B={}
function B._init(self,x,y) A._init(self,x); self.y=y end

local C={}
C.__index=C
function C.new(x,y,z)
  local self=setmetatable({},C)
  B._init(self,x,y)
  self.z=z
  return self
end

local c=C.new(1,2,3)
print(c.x,c.y,c.z)  -- 1 2 3

super-wrapper

Maak een helper super(self) die een proxyobject retourneert dat methoden van de ouder aanroept met self. Dit geeft een nettere syntaxis dan Parent.method(self, ...).

local function super(self)
  local mt = getmetatable(getmetatable(self).__index)
  if mt then
    return setmetatable({}, {__index=function(_,k)
      local parentCls = mt.__index or mt
      return function(...) return parentCls[k](self,...) end
    end})
  end
end
print("super() helper pattern shown")

Meerdere niveaus

Wanneer er meerdere niveaus van overerving zijn, roept elk niveau zijn directe ouder aan. De keten wordt automatisch voortgezet.

local L1={} L1.__index=L1
function L1:intro() return "L1" end

local L2={} L2.__index=L2
setmetatable(L2,{__index=L1})
function L2:intro() return L1.intro(self).."+L2" end

local L3={} L3.__index=L3
setmetatable(L3,{__index=L2})
function L3:intro() return L2.intro(self).."+L3" end

local obj=setmetatable({},L3)
print(obj:intro())  -- L1+L2+L3

Methoden uitbreiden

Breid een methode van de ouder uit: roep de ouderversie aan en voeg daarna extra gedrag toe. Dit is advies "vooraf" of "achteraf" zonder formeel AOP-framework.

local Logger={} Logger.__index=Logger
function Logger:log(msg) print("[LOG] "..msg) end

local TimedLogger={} TimedLogger.__index=TimedLogger
setmetatable(TimedLogger,{__index=Logger})

function TimedLogger:log(msg)
  local ts=os.date("%H:%M:%S")
  Logger.log(self,"["..ts.."] "..msg)  -- augment
end

local tl=setmetatable({},TimedLogger)
tl:log("Server started")

Valkuilen bij superaanroepen vermijden

Gebruik voor superaanroepen altijd de exacte naam van de ouderklasse, niet getmetatable(self).__index — de metatabelzoekactie kan een tussenliggende klasse retourneren in plaats van de echte ouder. Wees expliciet voor duidelijkheid en correctheid.

-- Correct: explicit parent reference
function Child:init(x)
  Base.init(self, x)  -- explicit, clear
end

-- Fragile: uses metatable lookup
function Child:initBad(x)
  local parent = getmetatable(getmetatable(self).__index)
  -- This may not be Base if hierarchy changes!
end
print("Be explicit with parent class references")

Super voor __tostring

Overschrijf __tostring in een kind en neem daarbij de representatie van de ouder op voor een volledige beschrijving.

local Base={}
Base.__index=Base
Base.__tostring=function(self) return "Base("..self.name..")" end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
Child.__tostring=function(self)
  local baseStr = Base.__tostring(self)
  return baseStr.." + Child(level="..self.level..")"
end

local c=setmetatable({name="X",level=5},Child)
print(tostring(c))  -- Base(X) + Child(level=5)

Beschermde templatemethode

Het templatemethodepatroon: de basisklasse definieert het skelet van een algoritme met aanroepen van abstracte stappen; subklassen implementeren de stappen.

local Processor={} Processor.__index=Processor
function Processor:run(data)
  data = self:preProcess(data)
  data = self:process(data)
  return self:postProcess(data)
end
function Processor:preProcess(d) return d end
function Processor:postProcess(d) return d end
function Processor:process(d) error("implement process()") end

local Upper={} Upper.__index=Upper
setmetatable(Upper,{__index=Processor})
function Upper:process(d) return d:upper() end

local p=setmetatable({},Upper)
print(p:run("hello"))  -- HELLO

Conventie voor superaanroepen

Conventie: voor interne initialisatiefuncties die alleen intern worden gebruikt, zet je een _ als voorvoegsel (bijvoorbeeld _init) en stel je alleen op het hoogste niveau van de constructor een openbare new() beschikbaar. Zo blijft de overervingsketen overzichtelijk.

-- Convention summary:
-- Animal._init(self, ...)  -- used for super calls
-- Dog.new(...)             -- only public constructor
-- Never call Dog._init from outside

local Foo={} Foo.__index=Foo
function Foo._init(self,x) self.x=x end
function Foo.new(x)
  return setmetatable({},Foo):_init(x) or
    (function() local s=setmetatable({},Foo); Foo._init(s,x); return s end)()
end
print("Convention: _init for super, new() for public")

Vraag over superaanroepen

Hoe roep je een methode van de ouder aan in Lua?

Beantwoord dit in de interactieve les

Samenvatting: superaanroepen

Roep methoden van de ouder altijd aan via een expliciete klassenverwijzing: Parent.method(self, ...). Gebruik de conventie _init voor coöperatieve constructors over meerdere niveaus van overerving.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Oudermethoden aanroepen met super” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Oudermethoden aanroepen met super”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Oudermethoden aanroepen met super”?

Roep methoden van de basisklasse expliciet aan voor coöperatieve initialisatie Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Oudermethoden aanroepen met super”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Enkelvoudige overerving met __index-koppeling
Oudermethoden aanroepen met super
Mixinpatronen
Overschrijven en polymorfisme

← Terug naar Lua Academy