Child-Methoden hinzufügen

Teil des Abschnitts Object Oriented Programming der Lua-Journey von Coddy — Lektion 34 von 70.

Vererbung ermöglicht es Kindklassen, auf Methoden der Elternklasse zuzugreifen, aber die wahre Stärke liegt im Hinzufügen neuer Methoden, die nur das Kind besitzt. Ein Dog kann alles, was ein Animal kann, plus Dinge, die spezifisch für Hunde sind – wie Bellen.

Das Hinzufügen einer kindspezifischen Methode ist unkompliziert: Definieren Sie sie einfach in der Tabelle der Kindklasse. Da Instanzen Methoden zuerst in ihrer eigenen Klasse nachschlagen, 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 vererbte als auch eigene Methoden verwenden:

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Ausgabe: Buddy is breathing (vererbt)
buddy:bark()     -- Ausgabe: Buddy says: Woof! (nur Kind-Klasse)

Die Elternklasse bleibt unverändert – der Aufruf von :bark() bei einem einfachen Animal würde fehlschlagen, da diese Methode dort nicht existiert. So ermöglicht es die Vererbung, Verhalten zu spezialisieren, während die gemeinsame Funktionalität an einem Ort beibehalten wird.

Aufgabe

Einfach

Lassen Sie uns eine Haustier-Hierarchie aufbauen, in der Katzen ihre eigene besondere Fähigkeit haben! Sie werden eine Pet-Basisklasse und eine Cat-Unterklasse erstellen, wobei Cat alles von Pet erbt, aber auch eine einzigartige Methode besitzt, die nur Katzen ausführen können.

Sie werden Ihren Code auf drei Dateien verteilen:

Pet.lua: Definieren Sie Ihre Basisklasse mit einem :new(name)-Konstruktor, der den Namen des Haustiers speichert. Fügen Sie eine :greet()-Methode hinzu, die den Namen des Haustiers gefolgt von says hello ausgibt. Richten Sie das Standard-Klassenmuster ein und geben Sie die Klasse zurück.
Cat.lua: Definieren Sie Ihre Unterklasse, die von Pet erbt. Der :new(name)-Konstruktor Ihrer Cat-Klasse sollte den Konstruktor der Basisklasse aufrufen, um den Namen zu initialisieren, und dann die Metatabelle wieder mit Cat verknüpfen. Fügen Sie eine unterklassenspezifische :purr()-Methode hinzu, die den Namen der Katze gefolgt von purrs contentedly ausgibt. Diese Methode existiert nur in Cat — Pet hat sie nicht!
main.lua: Binden Sie Ihr Cat-Modul ein, lesen Sie einen Namen aus der Eingabe, erstellen Sie eine Cat-Instanz und demonstrieren Sie, dass sie sowohl die geerbte :greet()-Methode als auch ihre eigene einzigartige :purr()-Methode verwenden kann.

Sie erhalten eine Eingabe: den Namen der Katze.

Erstellen Sie in Ihrer Hauptdatei eine Cat mit dem angegebenen Namen und rufen Sie dann :greet() gefolgt von :purr() in separaten Zeilen auf.

Wenn die Eingabe beispielsweise Whiskers ist, sollte die Ausgabe wie folgt aussehen:

Whiskers says hello
Whiskers purrs contentedly

Die erste Zeile stammt aus der geerbten :greet()-Methode, die in Pet definiert ist, während die zweite Zeile aus der :purr()-Methode stammt, die nur in Cat existiert. Dies zeigt, wie Unterklassen alles tun können, was ihre Basisklasse kann, plus ihre eigenen spezialisierten Verhaltensweisen!

Spickzettel

Unterklassen können neue Methoden hinzufügen, die nur sie besitzen, während sie gleichzeitig alle Methoden der Elternklasse erben. Instanzen suchen Methoden zuerst in ihrer eigenen Klasse und greifen dann auf die Elternklasse zurück.

Um eine unterklassenspezifische Methode hinzuzufügen, definieren Sie diese in der Tabelle der Unterklasse:

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 inherits from 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

-- Child-specific method
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Instanzen der Unterklasse können sowohl geerbte als auch eigene Methoden verwenden:

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Inherited from Animal
buddy:bark()     -- Child-only method

Die Elternklasse bleibt davon unberührt – sie hat keinen Zugriff auf die unterklassenspezifischen Methoden.

Probier es selbst

-- main.lua: Erstelle eine Katze 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 angegebenen Namen

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

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