La Programación Orientada a Objetos (POO) es un paradigma de programación que utiliza "objetos" para modelar datos y comportamientos. Lua, aunque no es un lenguaje orientado a objetos por naturaleza, proporciona mecanismos flexibles para implementar este paradigma. En este módulo, aprenderemos cómo utilizar tablas y metatablas para crear clases y objetos en Lua.

Conceptos Clave

  1. Tablas: En Lua, las tablas son estructuras de datos flexibles que pueden utilizarse para representar objetos.
  2. Metatablas: Permiten modificar el comportamiento de las tablas, facilitando la implementación de características de POO como la herencia.
  3. Métodos: Funciones que operan sobre objetos.
  4. Constructores: Funciones que crean e inicializan nuevos objetos.

Creación de Clases y Objetos

Definición de una Clase

En Lua, una clase puede ser representada por una tabla. A continuación, se muestra cómo definir una clase Persona:

-- Definición de la clase Persona
Persona = {}
Persona.__index = Persona

-- Constructor
function Persona:new(nombre, edad)
    local self = setmetatable({}, Persona)
    self.nombre = nombre
    self.edad = edad
    return self
end

-- Método para mostrar información
function Persona:mostrarInfo()
    print("Nombre: " .. self.nombre .. ", Edad: " .. self.edad)
end

Creación de Objetos

Para crear un objeto de la clase Persona, utilizamos el constructor new:

-- Creación de un objeto de la clase Persona
local persona1 = Persona:new("Juan", 30)
persona1:mostrarInfo()  -- Salida: Nombre: Juan, Edad: 30

Herencia

La herencia en Lua se puede implementar utilizando metatablas. A continuación, se muestra cómo crear una clase Estudiante que hereda de Persona:

-- Definición de la clase Estudiante que hereda de Persona
Estudiante = setmetatable({}, {__index = Persona})
Estudiante.__index = Estudiante

-- Constructor
function Estudiante:new(nombre, edad, carrera)
    local self = Persona.new(self, nombre, edad)
    self.carrera = carrera
    return self
end

-- Método para mostrar información del estudiante
function Estudiante:mostrarInfo()
    Persona.mostrarInfo(self)
    print("Carrera: " .. self.carrera)
end

Creación de Objetos de la Clase Derivada

-- Creación de un objeto de la clase Estudiante
local estudiante1 = Estudiante:new("Ana", 22, "Ingeniería")
estudiante1:mostrarInfo()
-- Salida:
-- Nombre: Ana, Edad: 22
-- Carrera: Ingeniería

Ejercicios Prácticos

Ejercicio 1: Definir una Clase Coche

  1. Define una clase Coche con los atributos marca y modelo.
  2. Implementa un método mostrarInfo que imprima la marca y el modelo del coche.
-- Solución
Coche = {}
Coche.__index = Coche

function Coche:new(marca, modelo)
    local self = setmetatable({}, Coche)
    self.marca = marca
    self.modelo = modelo
    return self
end

function Coche:mostrarInfo()
    print("Marca: " .. self.marca .. ", Modelo: " .. self.modelo)
end

-- Creación de un objeto de la clase Coche
local coche1 = Coche:new("Toyota", "Corolla")
coche1:mostrarInfo()  -- Salida: Marca: Toyota, Modelo: Corolla

Ejercicio 2: Herencia en la Clase Coche

  1. Define una clase CocheDeportivo que herede de Coche.
  2. Añade un atributo velocidadMaxima y un método mostrarInfo que también imprima la velocidad máxima.
-- Solución
CocheDeportivo = setmetatable({}, {__index = Coche})
CocheDeportivo.__index = CocheDeportivo

function CocheDeportivo:new(marca, modelo, velocidadMaxima)
    local self = Coche.new(self, marca, modelo)
    self.velocidadMaxima = velocidadMaxima
    return self
end

function CocheDeportivo:mostrarInfo()
    Coche.mostrarInfo(self)
    print("Velocidad Máxima: " .. self.velocidadMaxima .. " km/h")
end

-- Creación de un objeto de la clase CocheDeportivo
local cocheDeportivo1 = CocheDeportivo:new("Ferrari", "488", 330)
cocheDeportivo1:mostrarInfo()
-- Salida:
-- Marca: Ferrari, Modelo: 488
-- Velocidad Máxima: 330 km/h

Resumen

En esta sección, hemos aprendido cómo implementar la Programación Orientada a Objetos en Lua utilizando tablas y metatablas. Hemos cubierto la creación de clases, objetos, métodos y la implementación de herencia. Estos conceptos son fundamentales para estructurar y organizar el código de manera eficiente y modular.

En el siguiente módulo, exploraremos técnicas de depuración en Lua para identificar y solucionar errores en nuestros programas.

© Copyright 2024. Todos los derechos reservados