Lua Academy · Lektion

Elternmethoden mit super aufrufen

Rufen Sie Methoden der Basisklasse explizit auf, um eine kooperative Initialisierung zu ermöglichen

Elternmethoden mit super aufrufen ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Super-Aufrufe?

Wenn eine Unterklasse eine Methode der übergeordneten Klasse überschreibt, aber deren Logik weiterhin benötigt, ruft sie die übergeordnete Methode explizit auf. Lua besitzt kein super-Schlüsselwort — referenzieren Sie stattdessen direkt die übergeordnete Tabelle: 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 im Konstruktor

Konstruktoren von Unterklassen rufen Konstruktoren der übergeordneten Klasse über Parent.new() oder Parent._init(self,...) auf. Dadurch wird sichergestellt, dass die Initialisierung der übergeordneten Klasse für jede Instanz der Unterklasse ausgeführt wird.

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)

Kooperative Initialisierung

In tiefen Hierarchien initialisiert jede Ebene nur ihre eigenen Felder und ruft die Initialisierung der übergeordneten Klasse auf. So bleibt jede Klasse ausschließlich für ihre eigenen Felder verantwortlich.

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

Erstellen Sie eine Hilfsfunktion super(self), die ein Proxy-Objekt zurückgibt, das Methoden der übergeordneten Klasse mit self aufruft. Dadurch erhalten Sie eine übersichtlichere Syntax als mit 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")

Mehrere Ebenen

Bei mehreren Vererbungsebenen ruft jede Ebene ihre direkte übergeordnete Klasse auf. Die Kette wird automatisch weitergegeben.

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

Methodenerweiterung

Erweitern Sie eine Methode der übergeordneten Klasse: Rufen Sie deren Version auf und fügen Sie anschließend zusätzliches Verhalten hinzu. Dies entspricht „Before“- oder „After“-Advice ohne ein formales 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")

Fallstricke bei Super-Aufrufen vermeiden

Verwenden Sie für Super-Aufrufe immer den exakten Namen der übergeordneten Klasse und nicht getmetatable(self).__index — die Metatabellenauflösung kann eine Zwischenklasse statt der tatsächlichen übergeordneten Klasse zurückgeben. Seien Sie aus Gründen der Klarheit und Korrektheit explizit.

-- 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 für __tostring

Überschreiben Sie __tostring in einer Unterklasse und beziehen Sie dabei die Darstellung der übergeordneten Klasse ein, um eine vollständige Beschreibung zu erhalten.

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)

Geschützte Template-Methode

Das Template-Method-Muster: Die Basisklasse definiert ein Algorithmusgerüst mit Aufrufen abstrakter Schritte; Unterklassen implementieren diese Schritte.

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

Konvention für Super-Aufrufe

Konvention: Präfixen Sie nur intern verwendete Initialisierungsfunktionen mit _ (z. B. _init) und stellen Sie new() als öffentliche Methode nur im übergeordneten Konstruktor bereit. So bleibt die Vererbungskette übersichtlich.

-- 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")

Frage zu Super-Aufrufen

Wie rufen Sie eine Methode der übergeordneten Klasse in Lua auf?

Zusammenfassung: Super-Aufrufe

Rufen Sie Methoden der übergeordneten Klasse immer über eine explizite Klassenreferenz auf: Parent.method(self, ...). Verwenden Sie die Konvention _init für kooperative Konstruktoren über mehrere Vererbungsebenen hinweg.

Häufig gestellte Fragen

Ist die Lektion „Elternmethoden mit super aufrufen“ kostenlos?

Ja — der vollständige Text von „Elternmethoden mit super aufrufen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Elternmethoden mit super aufrufen“?

Rufen Sie Methoden der Basisklasse explizit auf, um eine kooperative Initialisierung zu ermöglichen Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Elternmethoden mit super aufrufen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Einfache Vererbung mit __index-Verkettung
Elternmethoden mit super aufrufen
Mixin-Muster
Überschreiben und Polymorphismus

← Zurück zu Lua Academy