Lua Academy · Lektion

Einfache Vererbung mit __index-Verkettung

Setzen Sie eine übergeordnete Klasse als __index einer Metatabelle, um Methoden zu erben

Einfache Vererbung mit __index-Verkettung ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Prototypkette

Einfachvererbung funktioniert, indem __index einer untergeordneten Klasse auf die übergeordnete Klasse gesetzt wird. Wenn eine Methode in der untergeordneten Klasse nicht gefunden wird, sucht Lua in der übergeordneten Klasse. Dadurch entsteht eine Prototypkette.

local Base={}
Base.__index=Base
function Base.new() return setmetatable({},Base) end
function Base:greet() print("Hello from Base") end

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

function Child.new() return setmetatable({},Child) end

local c=Child.new()
c:greet()  -- Hello from Base (inherited)

Reihenfolge der Methodenauflösung

Beim Aufruf einer Methode auf einer Instanz gilt: (1) in der Instanztabelle suchen, (2) in Child suchen (über __index), (3) in Base suchen (über __index in der Metatabelle von Child). Der erste Treffer wird verwendet.

local Base={}
Base.__index=Base
function Base:who() print("I am Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:who() print("I am Child") end  -- override

local b=setmetatable({},Base)
local c=setmetatable({},Child)
b:who()  -- I am Base
c:who()  -- I am Child (overrides)

Konstruktoren erben

Unterklassen können Konstruktoren der übergeordneten Klasse wiederverwenden, indem sie diese aufrufen, oder eigene Konstruktoren definieren, die die Initialisierung der übergeordneten Klasse erweitern.

local Animal={}
Animal.__index=Animal
function Animal.new(name,sound)
  return setmetatable({name=name,sound=sound},Animal)
end
function Animal:speak() print(self.name..": "..self.sound) end

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

function Dog.new(name)
  local self = Animal.new(name,"Woof")
  return setmetatable(self,Dog)
end
function Dog:fetch(item) print(self.name.." fetches "..item) end

local d=Dog.new("Rex")
d:speak(); d:fetch("ball")

Abstammung prüfen

Gehen Sie die Metatabellenkette nach oben, um zu prüfen, ob die Klasse eines Objekts von einer bestimmten Basisklasse erbt. So funktioniert instanceof in Lua.

local function instanceof(obj, cls)
  local mt = getmetatable(obj)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end

Super-Aufruf

Rufen Sie die Version einer überschriebenen Methode aus der übergeordneten Klasse auf, indem Sie direkt über die Klassentabelle der übergeordneten Klasse darauf zugreifen.

local Base={}
Base.__index=Base
function Base:init(x) self.x=x end
function Base:value() return self.x end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:init(x,y)
  Base.init(self,x)  -- call parent
  self.y=y
end
function Child:value() return Base.value(self)+self.y end

local c=setmetatable({},Child)
c:init(3,4)
print(c:value())  -- 7

Tiefe Vererbungskette

Erstellen Sie eine Hierarchie mit drei Ebenen: A → B → C. Die Methodensuche durchläuft die gesamte Kette, bis sie einen Treffer findet.

local A={}
A.__index=A
function A:aMethod() print("A method") end

local B={}
B.__index=B
setmetatable(B,{__index=A})
function B:bMethod() print("B method") end

local C={}
C.__index=C
setmetatable(C,{__index=B})

local c=setmetatable({},C)
c:bMethod()  -- from B
c:aMethod()  -- from A

Felder überschreiben

Eine Instanz kann Felder auf Klassenebene überschreiben, indem sie diese direkt setzt. Das Klassenfeld wird nicht geändert — es wird nur für diese Instanz überschattet.

local Creature={}
Creature.__index=Creature
Creature.hp=100
Creature.speed=10

function Creature.new()
  return setmetatable({},Creature)
end

local fast=Creature.new()
fast.speed=20  -- override for this instance

local normal=Creature.new()

print(fast.speed,normal.speed,Creature.speed)  -- 20  10  10

Vererbung auf Klassenebene

Wenn Sie setmetatable(Child, {__index=Parent}) setzen, greifen Lookups auf Klassenebene auf die übergeordnete Klasse zurück. Das bedeutet, dass Child.classMethod() Methoden der übergeordneten Klasse findet, sofern sie nicht überschrieben wurden.

local Vehicle={}
Vehicle.__index=Vehicle
Vehicle.maxSpeed=120
function Vehicle.describe() print("Vehicle") end

local Car={}
Car.__index=Car
setmetatable(Car,{__index=Vehicle})

Car.describe()  -- Vehicle (inherited class method)
print(Car.maxSpeed)  -- 120 (inherited class field)

Initialisierungskette

Für eine korrekte Initialisierung rufen Konstruktoren von Unterklassen die Konstruktoren der übergeordneten Klassen auf, damit der Zustand der übergeordneten Klasse eingerichtet wird. Führen Sie die Initialisierung entlang der Hierarchie weiter.

local Base={}
Base.__index=Base
function Base:_init(name) self.name=name end

local Mid={}
Mid.__index=Mid
setmetatable(Mid,{__index=Base})
function Mid:_init(name,level)
  Base._init(self,name)
  self.level=level
end

local Top={}
Top.__index=Top
setmetatable(Top,{__index=Mid})
function Top.new(name,level,role)
  local self=setmetatable({},Top)
  Mid._init(self,name,level)
  self.role=role
  return self
end

local t=Top.new("Alice",5,"admin")
print(t.name,t.level,t.role)

Abstrakte Basisklassen

Erstellen Sie eine Basisklasse mit nicht implementierten Methoden, die einen Fehler auslösen. Unterklassen müssen diese Methoden überschreiben. Dadurch werden Schnittstellenverträge in Lua's dynamischem Typsystem durchgesetzt.

local Serializer={}
Serializer.__index=Serializer
function Serializer:encode(data)
  error(self._type.." must implement encode()",2)
end
function Serializer:decode(str)
  error(self._type.." must implement decode()",2)
end

local JSONSerializer={_type="JSON"}
setmetatable(JSONSerializer,{__index=Serializer})
function JSONSerializer:encode(data)
  return "{"..tostring(data.key).."}"
end

local j=setmetatable({_type="JSON"},JSONSerializer)
print(j:encode({key="val"}))

Frage zur Vererbung

Was ermöglicht Einfachvererbung in Lua?

Zusammenfassung: Einfachvererbung

Setzen Sie setmetatable(Child, {__index = Parent}), um Methoden zu erben. Die __index-Kette stellt automatische Delegation bereit. Überschreiben Sie Methoden, indem Sie sie in Child definieren; rufen Sie die übergeordnete Methode explizit mit Parent.method(self) auf.

Häufig gestellte Fragen

Ist die Lektion „Einfache Vererbung mit __index-Verkettung“ kostenlos?

Ja — der vollständige Text von „Einfache Vererbung mit __index-Verkettung“ 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 „Einfache Vererbung mit __index-Verkettung“?

Setzen Sie eine übergeordnete Klasse als __index einer Metatabelle, um Methoden zu erben 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 1 von 4.

Wie lange dauert die Lektion „Einfache Vererbung mit __index-Verkettung“?

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