Vererbung

Ein Apfelbaum ist auch eine Pflanze: Er wächst Tag für Tag, und du kannst ihn wie jede andere Pflanze beschreiben. Er hat aber noch etwas: Er trägt Früchte. Du könntest die ganze Klasse Pflanze kopieren und ergänzen, aber dann müsstest du jede Änderung an Pflanzen zweimal machen. Stattdessen kann eine Klasse von einer anderen Klasse erben: Sie bekommt alle Methoden der anderen Klasse, fügt eigene hinzu und ersetzt die, die anders funktionieren sollen:

local Pflanze = {}
Pflanze.__index = Pflanze

function Pflanze.new(name, tage)
    local pflanze = {name = name, tage = tage, alter = 0}
    setmetatable(pflanze, Pflanze)
    return pflanze
end

function Pflanze:wachsen()
    self.alter = self.alter + 1
end

function Pflanze:beschreiben()
    return self.name .. ", Tag " .. self.alter .. " von " .. self.tage
end

local Baum = {}
Baum.__index = Baum
setmetatable(Baum, {__index = Pflanze})

function Baum.new(name, tage, frucht)
    local baum = Pflanze.new(name, tage)
    setmetatable(baum, Baum)
    baum.frucht = frucht
    return baum
end

function Baum:beschreiben()
    return Pflanze.beschreiben(self) .. ", trägt " .. self.frucht
end

local weizen = Pflanze.new("Weizen", 2)
local apfel = Baum.new("Apfelbaum", 30, "Äpfel")
weizen:wachsen()
apfel:wachsen()
print(weizen:beschreiben())
print(apfel:beschreiben())

Das gibt Folgendes aus:

Weizen, Tag 1 von 2
Apfelbaum, Tag 1 von 30, trägt Äpfel

Das ist neu:

• local Baum = {} und Baum.__index = Baum machen Baum zu einer Klasse, genau wie Pflanze.
• setmetatable(Baum, {__index = Pflanze}) gibt der Klasse Baum eine Metatabelle: Was Baum nicht hat, sucht Lua in Pflanze. Diese Zeile ist die Vererbung. Baum ist eine Unterklasse von Pflanze, und Pflanze ist seine Elternklasse.
• Baum.new wiederholt nicht, was Pflanze.new tut. Es ruft Pflanze.new auf, um eine Pflanze mit Name, Tagen und Alter zu erzeugen, macht sie dann mit setmetatable(baum, Baum) zu einem Baum (eine Tabelle hat nur eine Metatabelle, dies ersetzt also Pflanze) und fügt den eigenen Schlüssel des Baums hinzu, frucht.

Wenn du apfel:wachsen() aufrufst, sucht Lua wachsen Schritt für Schritt: im apfel selbst (nein), in Baum über die Metatabelle des Apfelbaums (nein) und in Pflanze über die Metatabelle von Baum (ja). Es ist eine Kette: apfel → Baum → Pflanze.

Eine Methode überschreiben. Baum hat sein eigenes beschreiben. Lua hört beim ersten beschreiben auf zu suchen, das es findet, und für einen Baum ist das das in Baum. Es ersetzt (überschreibt) also das in Pflanze. Weizen ist eine gewöhnliche Pflanze und benutzt deshalb weiter das beschreiben aus Pflanze. Die Version des Baums muss die Arbeit der Elternklasse nicht wiederholen: Pflanze.beschreiben(self) ruft die Methode der Elternklasse für denselben Baum auf. Beachte den Punkt und das von Hand übergebene self. self:beschreiben() würde das eigene beschreiben des Baums noch einmal aufrufen, das sich immer wieder selbst aufrufen würde, bis das Programm mit stack overflow endet.

Typische Fehler:

• setmetatable(Baum, {__index = Pflanze}) vergessen: Bäume finden die Methoden der Pflanzen nicht, und apfel:wachsen() endet mit attempt to call a nil value (method 'wachsen').
• setmetatable(baum, Baum) in Baum.new vergessen: Der neue Baum bleibt eine gewöhnliche Pflanze. apfel:beschreiben() benutzt dann die Version aus Pflanze und sagt nichts über Früchte, und die eigenen Methoden des Baums werden nicht gefunden.
• Zu erwarten, dass Metamethoden vererbt werden. Lua sucht __tostring, __lt, __add und die anderen direkt in der Metatabelle des Objekts, nicht über __index. Hat Pflanze ein __tostring, werden Bäume weiter als table: 0x… ausgegeben, bis du Baum.__tostring = Pflanze.__tostring hinzufügst.