Programación orientada a objetos en Lua

La programación orientada a objetos (Object Oriented Programming, OOP) es una arquitectura de programación informática muy popular.

Los siguientes lenguajes de programación todos admiten la programación orientada a objetos:

• C++

• Java

• Objective-C

• Smalltalk

• C#

• Ruby

Características de la programación orientada a objetos

• 1）Encapsulación: Se refiere a la característica de poder colocar la información, las funciones y las respuestas de un ente en un solo objeto.

• 2）Herencia: El método de herencia permite expandir el programa sin modificarlo, lo que asegura que las funciones originales se conserven y se pueda expandir nuevas funciones. Esto es beneficioso para reducir la repetición de código y aumentar la eficiencia del desarrollo de software.

• 3）Polimorfismo: La misma operación actúa sobre diferentes objetos, puede tener diferentes interpretaciones y producir diferentes resultados de ejecución. En tiempo de ejecución, se puede llamar a métodos de la clase derivada a través de un puntero apuntando a la clase base.

• 4）Abstracción: La abstracción es una vía para simplificar problemas complejos de la realidad, que puede encontrar la definición de clase más adecuada para problemas específicos y explicar problemas en el nivel de herencia más adecuado.

Programación orientada a objetos en Lua

Sabemos que los objetos están compuestos por atributos y métodos. La estructura más básica en LUA es la tabla, por lo que se necesita una tabla para describir los atributos del objeto.

Las funciones en Lua se pueden usar para representar métodos. Por lo tanto, las clases en LUA se pueden representar a través de tablas + function simular.

En cuanto a la herencia, se puede simular a través de metatable (no se recomienda, ya que solo es suficiente para simular los objetos más básicos en la mayoría de los casos).

Las tablas en Lua no solo son un tipo de objeto en algún sentido. Al igual que los objetos, las tablas tienen un estado (variables de miembros); también tienen una naturaleza independiente de los valores del objeto, especialmente cuando dos tablas con valores diferentes representan dos objetos diferentes; un objeto puede tener diferentes valores en diferentes momentos, pero siempre es un objeto; al igual que los objetos, el ciclo de vida de las tablas no tiene relación con lo que las creó o dónde se crearon. Los objetos tienen sus funciones miembro, y las tablas también tienen:

Account = {saldo = 0}
function Account:withdraw (v)
　　　　Account.saldo = Account.saldo　-　v
end

Esta definición crea una nueva función y se almacena en el dominio withdraw del objeto Account, a continuación, podemos llamarlo de la siguiente manera:

Account.withdraw (100.00)

un ejemplo simple

A continuación, se muestra una clase simple que contiene tres propiedades: area, longitud y anchura, el método printArea se utiliza para imprimir el resultado de la calculación:

--　clase meta
Rectangle = {area = 0, longitud = 0, anchura = 0}
--　método new de la clase derivada
function Rectangle:new (o, longitud, ancho)
　　o = o or {}
　　setmetatable (o, self)
　　self.__index = self
　　self.longitud = longitud or 0
　　self.anchura = anchura or 0
　　self.area = longitud*anchura;
　　return o
end
--　método printArea de la clase derivada
function Rectangle:printArea ()
　　print("Área del rectángulo", self.area)
end

Crear objeto

La creación de un objeto es el proceso de asignar memoria para el ejemplo de la clase. Cada clase tiene su propia memoria y comparte datos comunes.

r = Rectangle:new(nil,10,20)

Acceder a la propiedad

Podemos usar un punto (.) para acceder a las propiedades de la clase:

print(r.longitud)

Acceder a la función miembro

Podemos usar dos puntos : para acceder a las funciones miembro de la clase:

r:printArea ()

La memoria se asigna en el momento de la inicialización del objeto.

ejemplo completo

A continuación, se muestra un ejemplo completo de programación orientada a objetos en Lua:

--　clase meta
Shape = {area = 0}
--　clase base método new
function Shape:new (o, lado)
　　o = o or {}
　　setmetatable (o, self)
　　self.__index = self
　　lado = lado or 0
　　self.area = lado*lado;
　　return o
end
--　clase base método printArea
function Shape:printArea ()
　　print("Área", self.area)
end
--　Crear objeto
myshape = Shape:new (nil,10)
myshape:printArea ()

Ejecutar el programa anterior, el resultado de salida es:

Área　　　　　100

Herencia Lua

La herencia es la capacidad de un objeto para utilizar las propiedades y métodos de otro objeto. Se puede usar para expandir las propiedades y métodos de la clase base.

A continuación, se muestra un ejemplo simple de herencia:

--　clase meta
Shape = {area = 0}
--　clase base método new
function Shape:new (o, lado)
　　o = o or {}
　　setmetatable (o, self)
　　self.__index = self
　　lado = lado or 0
　　self.area = lado*lado;
　　return o
end
--　clase base método printArea
function Shape:printArea ()
　　print("Área", self.area)
end

A continuación, se muestra un ejemplo en el que el objeto Square hereda la clase Shape:

Square = Shape:new ()
--　método de clase derivada new
function Square:new (o, lado)
　　o = o o Shape:new (o, lado)
　　setmetatable (o, self)
　　self.__index = self
　　return o
end

ejemplo completo

A continuación, se muestra un ejemplo en el que se hereda una clase simple para extender el método de la clase derivada, la clase derivada mantiene los miembros de la clase heredada variables y métodos:

--　clase meta
Shape = {area = 0}
--　clase base método new
function Shape:new (o, lado)
　　o = o or {}
　　setmetatable (o, self)
　　self.__index = self
　　lado = lado or 0
　　self.area = lado*lado;
　　return o
end
--　clase base método printArea
function Shape:printArea ()
　　print("Área", self.area)
end
--　Crear objeto
myshape = Shape:new (nil,10)
myshape:printArea ()
Square = Shape:new ()
--　Método de clase derivada new
function Square:new (o, lado)
　　o = o o Shape:new (o, lado)
　　setmetatable (o, self)
　　self.__index = self
　　return o
end
--　Método de clase derivada printArea
function Square:printArea ()
　　print("Área del cuadrado", self.area)
end
--　Crear objeto
mysquare = Square:new (nil,10)
mysquare:printArea ()
Rectangle = Shape:new ()
--　Método de clase derivada new
function Rectangle:new (o, longitud, ancho)
　　o = o o Shape:new (o)
　　setmetatable (o, self)
　　self.__index = self
　　self.area = longitud　*　ancho
　　return o
end
--　Método de clase derivada printArea
function Rectangle:printArea ()
　　print("Área del rectángulo", self.area)
end
--　Crear objeto
myrectangle = Rectangle:new (nil,10,20)
myrectangle:printArea ()

Ejecutando el código anterior, el resultado de salida es:

Área　　　　　100
Área del cuadrado　　　　　100
Área del rectángulo　　　　　200

Sobrescripción de funciones

En Lua podemos sobrescribir funciones de la clase base, definiendo nuestra propia implementación en la clase derivada:

--　Método de clase derivada printArea
function Square:printArea ()
　　print("Área del cuadrado", self.area)
end