Classes and inheritance¶

In Lua, defining classes and inheritance is often done manually using setmetatable and manually setting __index. While this is a fine approach, it can be tedious and error-prone. Thankfully, in Lemonate, you don’t have to go through that trouble! We provide a convenient Class system that makes object-oriented programming in Lua much easier.

This article will guide you through how to define and use classes in Lemonate, complete with examples and explanations.

Defining a Class¶

To define a new class in Lemonate, you simply use Class.new:

local MyNewClass = Class.new()

If your class needs to inherit from another class, just pass the base class as an argument:

local MyNewClass = Class.new(BaseClass)

With this, MyNewClass is now a subclass of BaseClass, automatically inheriting its methods and properties.

The Constructor (__new)¶

Every class needs a way to initialize instances. In Lemonate, you define a constructor by implementing the __new method:

function MyNewClass:__new(param1, param2)
    self.param1 = param1
    self.param2 = param2
    print("A new instance of MyNewClass has been created!")
end

The self variable refers to the instance being created, allowing you to assign properties and perform setup logic.

Creating an Instance¶

Once a class is defined, creating an instance is straightforward:

local myObject = MyNewClass.new("Hello", 42)

This calls __new, initializing myObject with the given parameters.

Adding Methods to a Class¶

You can define additional methods on your class just like you would in Lua’s usual object-oriented approach:

function MyNewClass:greet()
    print("Hello, I have param1:", self.param1)
end

Now, you can call this method on an instance:

myObject:greet()  -- Output: Hello, I have param1: Hello

Inheritance and Overriding Methods¶

Since Lemonate’s Class.new supports inheritance, your new class can override methods from the base class.

local Animal = Class.new()

function Animal:__new(name)
    self.name = name
end

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

local Dog = Class.new(Animal)

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

local myDog = Dog.new("Buddy")
myDog:speak()  -- Output: Buddy barks!

If a method is not overridden, the base class’s method is used instead.

Conclusion¶

Lemonate simplifies working with classes and inheritance in Lua, sparing you from manually handling setmetatable and __index. With Class.new, defining object-oriented structures is clean, readable, and intuitive. Now, go forth and create some amazing classes—just remember, with great power comes great responsibility (and possibly some bugs to fix).