Child-Methoden hinzufügen

Teil des Abschnitts Objektorientierte Programmierung der Lua-Journey von Coddy. Lektion 34 von 70.

Vererbung ermöglicht es Kindklassen, auf Methoden der Elternklasse zuzugreifen, aber die eigentliche Stärke entsteht durch das Hinzufügen von neuen Methoden, die nur die Kindklasse besitzt. Ein Dog kann alles tun, was ein Animal kann, und zusätzlich Dinge, die für Hunde einzigartig sind, wie zum Beispiel Bellen.

Das Hinzufügen einer kindklassenspezifischen Methode ist unkompliziert: Definiere sie einfach in der Tabelle der Kindklasse. Da Instanzen zunächst in ihrer eigenen Klasse nach Methoden suchen, finden sie die neue Methode, ohne die Elternklasse zu beeinflussen.

local Animal = {}
Animal.__index = Animal

function Animal:new(name)
    local obj = {name = name}
    setmetatable(obj, Animal)
    return obj
end

function Animal:breathe()
    print(self.name .. " is breathing")
end

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

function Dog:new(name)
    local obj = Animal.new(Animal, name)
    setmetatable(obj, Dog)
    return obj
end

-- Neue Methode nur in Dog
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Jetzt können Dog-Instanzen sowohl geerbte als auch eigene Methoden verwenden:

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Ausgabe: Buddy atmet (geerbt)
buddy:bark()     -- Ausgabe: Buddy sagt: Woof! (nur Kind)

Die Elternklasse bleibt unverändert: Der Aufruf von :bark() für ein einfaches Animal würde fehlschlagen, da diese Methode dort nicht existiert. So ermöglicht Vererbung, Verhalten zu spezialisieren und gleichzeitig gemeinsam genutzte Funktionalität an einer Stelle zu halten.

Aufgabe

Einfach

Lass uns eine Haustier-Hierarchie erstellen, in der Katzen eine besondere Fähigkeit haben! Du erstellst eine übergeordnete Klasse Pet und eine untergeordnete Klasse Cat, wobei Cat alles von Pet erbt, aber zusätzlich über eine einzigartige Methode verfügt, die nur Katzen ausführen können.

Du organisierst deinen Code über drei Dateien:

Pet.lua: Definiere deine übergeordnete Klasse mit einem :new(name)-Konstruktor, der den Namen des Haustiers speichert. Füge eine :greet()-Methode hinzu, die den Namen des Haustiers gefolgt von says hello ausgibt. Richte das standardmäßige Klassenmuster ein und gib die Klasse zurück.
Cat.lua: Definiere deine untergeordnete Klasse, die von Pet erbt. Der :new(name)-Konstruktor von Cat sollte den Konstruktor der übergeordneten Klasse aufrufen, um den Namen zu initialisieren, und anschließend die Metatabelle wieder mit Cat verknüpfen. Füge eine spezifische :purr()-Methode für die untergeordnete Klasse hinzu, die den Namen der Katze gefolgt von purrs contentedly ausgibt. Diese Methode existiert nur in Cat: Pet hat sie nicht!
main.lua: Binde dein Cat-Modul ein, lies einen Namen aus der Eingabe, erstelle eine Cat-Instanz und zeige, dass sie sowohl die geerbte Methode :greet() als auch ihre eigene einzigartige Methode :purr() verwenden kann.

Du erhältst eine Eingabe: den Namen der Katze.

Erstelle in deiner Hauptdatei eine Cat mit dem angegebenen Namen und rufe anschließend :greet() gefolgt von :purr() in separaten Zeilen auf.

Wenn die Eingabe beispielsweise Whiskers lautet, sollte die Ausgabe folgendermaßen aussehen:

Whiskers says hello
Whiskers purrs contentedly

Die erste Zeile stammt von der geerbten Methode :greet(), die in Pet definiert ist, während die zweite Zeile von der Methode :purr() stammt, die nur in Cat existiert. Dies zeigt, wie untergeordnete Klassen alles tun können, was ihre übergeordnete Klasse kann, und zusätzlich über eigene spezialisierte Verhaltensweisen verfügen!

Probier es selbst

-- main.lua: Erstelle eine Cat und demonstriere Vererbung

local Cat = require('Cat')

-- Lies den Namen der Katze aus der Eingabe
local name = io.read()

-- TODO: Erstelle eine Cat-Instanz mit dem gegebenen Namen

-- TODO: Rufe die geerbte :greet()-Methode auf (von Pet)

-- TODO: Rufe die Cat-spezifische :purr()-Methode auf