Añadir métodos hijos

Parte de la sección Programación Orientada a Objetos del Journey de Lua de Coddy. Lección 34 de 70.

La herencia permite que las clases hijas accedan a los métodos del padre, pero el verdadero poder proviene de añadir nuevos métodos que solo tiene la clase hija. Un Dog puede hacer todo lo que puede hacer un Animal, además de cosas propias de los perros, como ladrar.

Añadir un método específico del hijo es sencillo: basta con definirlo en la tabla de la clase hija. Como las instancias buscan primero los métodos en su propia clase, encontrarán el nuevo método sin afectar a la clase padre.

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 hereda de 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

-- Nuevo método solo en Dog
function Dog:bark()
    print(self.name .. " says: Woof!")
end

Ahora las instancias de Dog pueden usar tanto métodos heredados como métodos únicos:

local buddy = Dog:new("Buddy")
buddy:breathe()  -- Salida: Buddy está respirando (heredado)
buddy:bark()     -- Salida: Buddy dice: ¡Woof! (solo del hijo)

La clase padre permanece sin cambios: llamar a :bark() en un Animal simple fallaría, ya que ese método no existe allí. Así es como la herencia te permite especializar el comportamiento mientras mantienes la funcionalidad compartida en un solo lugar.

Desafío

Fácil

¡Construyamos una jerarquía de mascotas en la que los gatos tengan su propia habilidad especial! Crearás una clase padre Pet y una clase hija Cat, donde Cat hereda todo de Pet, pero también tiene un método único que solo los gatos pueden realizar.

Organizarás tu código en tres archivos:

Pet.lua: Define tu clase padre con un constructor :new(name) que almacene el nombre de la mascota. Incluye un método :greet() que imprima el nombre de la mascota seguido de says hello. Configura el patrón de clase estándar y devuelve la clase.
Cat.lua: Define tu clase hija que hereda de Pet. El constructor :new(name) de Cat debe llamar al constructor padre para inicializar el nombre y, después, volver a vincular la metatabla a Cat. Añade un método específico de la hija, :purr(), que imprima el nombre del gato seguido de purrs contentedly. ¡Este método solo existe en Cat: Pet no lo tiene!
main.lua: Requiere tu módulo Cat, lee un nombre de la entrada, crea una instancia de Cat y demuestra que puede usar tanto el método heredado :greet() como su propio método único :purr().

Recibirás una entrada: el nombre del gato.

En tu archivo principal, crea un Cat con el nombre proporcionado y, después, llama a :greet() seguido de :purr() en líneas separadas.

Por ejemplo, si la entrada es Whiskers, la salida debería ser:

Whiskers says hello
Whiskers purrs contentedly

La primera línea proviene del método heredado :greet() definido en Pet, mientras que la segunda línea proviene del método :purr() que solo existe en Cat. ¡Esto demuestra cómo las clases hijas pueden hacer todo lo que puede hacer su clase padre, además de tener sus propios comportamientos especializados!

Pruébalo tú mismo

-- main.lua: Crea un Cat y demuestra la herencia

local Cat = require('Cat')

-- Lee el nombre del gato desde la entrada
local name = io.read()

-- TODO: Crea una instancia de Cat con el nombre dado

-- TODO: Llama al método heredado :greet() (de Pet)

-- TODO: Llama al método :purr() específico de Cat