Object-Oriented Programming in Lua

Tables as objects

In Lua, tables serve as the foundation for object-oriented programming (OOP). Unlike traditional OOP languages, Lua doesn't have built-in classes, but tables can be used to create objects with properties and methods.

To create an object, we define a table with key-value pairs:

local person = {

??? name = "John",

??? age = 30,

??? greet = function(self)

??????? print("Hello, I'm " .. self.name)

??? end

}

This table represents a person object with properties (name, age) and a method (greet). We can access and modify these properties:

print(person.name)? -- Output: John

person.age = 31

person:greet()? -- Output: Hello, I'm John

Metatables and metamethods

Metatables enhance the behavior of tables, allowing us to define custom operations. Metamethods are special functions within metatables that define how objects interact.

Here's a comparison of common metamethods:

Metamethod

Purpose

__index

Lookup for non-existent keys

__newindex

Assignment to non-existent keys

__call

Make the table callable like a function

__add

Define addition operation

__tostring

String representation of the object

?

Example of using a metatable:

local Person = {}

Person.__index = Person

function Person:new(name, age)

??? local obj = setmetatable({name = name, age = age}, Person)

??? return obj

end

function Person:greet()

??? print("Hello, I'm " .. self.name)

end

local john = Person:new("John", 30)

john:greet()? -- Output: Hello, I'm John

?

Inheritance and polymorphism

Lua supports inheritance through metatables. We can create a base class and derive subclasses from it:

local Animal = {}

Animal.__index = Animal

function Animal:new(name)

??? return setmetatable({name = name}, Animal)

end

function Animal:speak()

??? print("The animal makes a sound")

end

local Dog = setmetatable({}, {__index = Animal})

Dog.__index = Dog

function Dog:new(name)

??? return setmetatable(Animal:new(name), Dog)

end

function Dog:speak()

??? print(self.name .. " barks")

end

local generic_animal = Animal:new("Generic")

local fido = Dog:new("Fido")

generic_animal:speak()? -- Output: The animal makes a sound

fido:speak()? -- Output: Fido barks

This example demonstrates both inheritance and polymorphism. The Dog class inherits from Animal, and we can override methods to achieve polymorphic behavior.

Now that we've covered the basics of object-oriented programming in Lua, let's explore Lua's standard libraries to enhance our programming capabilities.