Sobrescritura de métodos

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

Hasta ahora, las clases child han heredado métodos de las clases principales y han añadido otros nuevos. Pero ¿qué ocurre si una clase child necesita el mismo nombre de método con un comportamiento diferente? Esto se denomina sobrescritura de métodos.

Cuando defines un método en una clase hija con el mismo nombre que uno de la clase padre, la versión de la clase hija tiene prioridad. La cadena de búsqueda de Lua comprueba primero la clase hija; si encuentra allí el método, deja de buscar.

local Animal = {}
Animal.__index = Animal

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

function Animal:speak()
    print(self.name .. " makes a sound")
end

-- Dog sobrescribe speak()
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

function Dog:speak()
    print(self.name .. " barks: Woof!")
end

Ahora cada clase responde de manera diferente a la misma llamada de método:

local generic = Animal:new("Creature")
local buddy = Dog:new("Buddy")

generic:speak()  -- Salida: Creature hace un sonido
buddy:speak()    -- Salida: Buddy ladra: ¡Woof!

El Dog :speak() reemplaza por completo la versión del padre para las instancias de Dog. Esto te permite crear un comportamiento especializado mientras mantienes una interfaz coherente: cada animal puede usar :speak(), pero cada especie lo hace de manera diferente.

Desafío

Fácil

¡Construyamos un pequeño reino animal donde distintas criaturas hablen de sus propias maneras únicas! Crearás una clase principal Animal y dos clases hijas, Cat y Cow, que sobrescribirán el método :speak() de la clase principal, cada una con su propio comportamiento especializado.

Organizarás tu código en cuatro archivos:

Animal.lua: Tu clase base con un constructor :new(name) que almacena el nombre del animal. Incluye un método :speak() que imprime el nombre del animal seguido de makes a sound. Este es el comportamiento predeterminado que las clases hijas sobrescribirán.
Cat.lua: Una clase hija que hereda de Animal. Su constructor :new(name) debe llamar al constructor de la clase principal y después volver a vincular la metatabla a Cat. Sobrescribe el método :speak() para que los gatos digan algo diferente: imprime el nombre del gato seguido de meows: Meow!
Cow.lua: Otra clase hija que hereda de Animal. Configura el constructor de la misma manera que en Cat. Sobrescribe :speak() para que las vacas impriman su nombre seguido de moos: Moo!
main.lua: ¡Une todo! Lee dos nombres de la entrada, crea un Cat con el primer nombre y un Cow con el segundo nombre, y después llama a :speak() en cada uno para demostrar que el mismo nombre de método produce una salida diferente según la clase.

Recibirás dos entradas:

El nombre del gato
El nombre de la vaca

En tu archivo principal, crea ambos animales y llama a :speak() primero en el gato y después en la vaca.

Por ejemplo, si las entradas son Whiskers y Bessie, la salida debería ser:

Whiskers meows: Meow!
Bessie moos: Moo!

Observa cómo ambos animales responden a la misma llamada al método :speak(), pero cada uno produce una salida específica de su tipo. La versión de Cat reemplaza por completo el comportamiento genérico de la clase principal, "makes a sound", y lo mismo ocurre con la de Cow. ¡Esto es la sobrescritura de métodos en acción: misma interfaz, implementaciones diferentes!

Pruébalo tú mismo

-- main.lua: Reúne todo

local Cat = require('Cat')
local Cow = require('Cow')

-- Leer la entrada
local catName = io.read()
local cowName = io.read()

-- TODO: Crea un Cat con el primer nombre

-- TODO: Crea un Cow con el segundo nombre

-- TODO: Llama a :speak() en el cat primero, luego en el cow