Inheritance in Lua

Intermediate ~30 min read

Inheritance allows you to create new classes based on existing ones, reusing and extending functionality. In Lua, inheritance is implemented using metatables and the __index metamethod. You can create class hierarchies, override methods, and implement polymorphism. Let's explore how to build powerful inheritance systems in Lua!

Basic Inheritance

Create a child class that inherits from a parent class:

-- Parent class
local Animal = {}
Animal.__index = Animal

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

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

-- Child class
local Dog = setmetatable({}, {__index = Animal})
Dog.__index = Dog

function Dog:new(name, breed)
    local self = setmetatable({}, Dog)
    self.name = name
    self.breed = breed
    return self
end

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

local animal = Animal:new("Generic Animal")
local dog = Dog:new("Buddy", "Golden Retriever")

animal:speak()  -- Generic Animal makes a sound
dog:speak()     -- Buddy barks: Woof!

How it works:

Dog has Animal as its metatable
When a method isn't found in Dog, Lua looks in Animal
This creates an inheritance chain: Dog → Animal

-- OOP: Inheritance in Lua

-- Base class
local Animal = {}
Animal.__index = Animal

function Animal.new(name, sound)
    local self = setmetatable({}, Animal)
    self.name = name
    self.sound = sound
    return self
end

function Animal:makeSound()
    print(self.name .. " says " .. self.sound)
end

function Animal:describe()
    print("This is " .. self.name)
end

-- Derived class: Dog
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})  -- Dog inherits from Animal

function Dog.new(name, breed)
    local self = setmetatable({}, Dog)
    self.name = name
    self.sound = "Woof"
    self.breed = breed
    return self
end

function Dog:fetch()
    print(self.name .. " is fetching!")
end

-- Derived class: Cat
local Cat = {}
Cat.__index = Cat
setmetatable(Cat, {__index = Animal})

function Cat.new(name, color)
    local self = setmetatable({}, Cat)
    self.name = name
    self.sound = "Meow"
    self.color = color
    return self
end

function Cat:scratch()
    print(self.name .. " is scratching!")
end

-- Create instances
local dog = Dog.new("Buddy", "Golden Retriever")
local cat = Cat.new("Whiskers", "Orange")

-- Inherited methods
dog:makeSound()  -- From Animal
dog:describe()   -- From Animal
dog:fetch()      -- Dog's own method

cat:makeSound()  -- From Animal
cat:describe()   -- From Animal
cat:scratch()    -- Cat's own method

-- Shape hierarchy
local Shape = {}
Shape.__index = Shape

function Shape.new()
    local self = setmetatable({}, Shape)
    return self
end

function Shape:area()
    error("Must implement area() method")
end

-- Rectangle inherits from Shape
local Rectangle = {}
Rectangle.__index = Rectangle
setmetatable(Rectangle, {__index = Shape})

function Rectangle.new(width, height)
    local self = setmetatable({}, Rectangle)
    self.width = width
    self.height = height
    return self
end

function Rectangle:area()
    return self.width * self.height
end

-- Circle inherits from Shape
local Circle = {}
Circle.__index = Circle
setmetatable(Circle, {__index = Shape})

function Circle.new(radius)
    local self = setmetatable({}, Circle)
    self.radius = radius
    return self
end

function Circle:area()
    return math.pi * self.radius ^ 2
end

local rect = Rectangle.new(5, 3)
local circle = Circle.new(4)

print("\nShapes:")
print("Rectangle area:", rect:area())
print("Circle area:", circle:area())

-- Vehicle hierarchy
local Vehicle = {}
Vehicle.__index = Vehicle

function Vehicle.new(make, model)
    local self = setmetatable({}, Vehicle)
    self.make = make
    self.model = model
    self.speed = 0
    return self
end

function Vehicle:accelerate(amount)
    self.speed = self.speed + amount
    print(self.make .. " " .. self.model .. " speed: " .. self.speed)
end

function Vehicle:brake(amount)
    self.speed = math.max(0, self.speed - amount)
    print(self.make .. " " .. self.model .. " speed: " .. self.speed)
end

-- Car inherits from Vehicle
local Car = {}
Car.__index = Car
setmetatable(Car, {__index = Vehicle})

function Car.new(make, model, doors)
    local self = setmetatable({}, Car)
    self.make = make
    self.model = model
    self.speed = 0
    self.doors = doors
    return self
end

function Car:honk()
    print("Beep beep!")
end

local car = Car.new("Toyota", "Camry", 4)
car:accelerate(30)  -- Inherited
car:accelerate(20)  -- Inherited
car:honk()          -- Car's own method
car:brake(25)       -- Inherited

Output

Click Run to execute your code

Calling Parent Methods (Super)

Access parent class methods from child class:

local Animal = {}
Animal.__index = Animal

function Animal:new(name)
    local self = setmetatable({}, Animal)
    self.name = name
    self.energy = 100
    return self
end

function Animal:eat()
    self.energy = self.energy + 10
    print(self.name .. " is eating")
end

-- Child class
local Dog = setmetatable({}, {__index = Animal})
Dog.__index = Dog

function Dog:new(name, breed)
    -- Call parent constructor
    local self = Animal.new(self, name)
    setmetatable(self, Dog)
    self.breed = breed
    return self
end

function Dog:eat()
    -- Call parent method
    Animal.eat(self)
    print("Energy is now: " .. self.energy)
end

local dog = Dog:new("Buddy", "Golden Retriever")
dog:eat()
-- Buddy is eating
-- Energy is now: 110

-- OOP: Calling Parent (Super) Methods

-- Base class
local Animal = {}
Animal.__index = Animal

function Animal.new(name)
    local self = setmetatable({}, Animal)
    self.name = name
    return self
end

function Animal:eat(food)
    print(self.name .. " is eating " .. food)
end

function Animal:sleep()
    print(self.name .. " is sleeping")
end

-- Derived class that calls parent methods
local Dog = {}
Dog.__index = Dog
setmetatable(Dog, {__index = Animal})

function Dog.new(name, breed)
    -- Call parent constructor
    local self = Animal.new(name)
    setmetatable(self, Dog)
    self.breed = breed
    return self
end

-- Override parent method but call it
function Dog:eat(food)
    print(self.name .. " (a " .. self.breed .. ") is excited!")
    Animal.eat(self, food)  -- Call parent method
    print("Wag wag!")
end

function Dog:bark()
    print(self.name .. " says Woof!")
end

local dog = Dog.new("Buddy", "Golden Retriever")
dog:eat("kibble")
dog:sleep()  -- Inherited, not overridden
dog:bark()

-- Person and Employee hierarchy
local Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:introduce()
    print("Hi, I'm " .. self.name .. " and I'm " .. self.age .. " years old")
end

-- Employee extends Person
local Employee = {}
Employee.__index = Employee
setmetatable(Employee, {__index = Person})

function Employee.new(name, age, jobTitle, salary)
    local self = Person.new(name, age)
    setmetatable(self, Employee)
    self.jobTitle = jobTitle
    self.salary = salary
    return self
end

-- Override and extend parent method
function Employee:introduce()
    Person.introduce(self)  -- Call parent method
    print("I work as a " .. self.jobTitle)
end

function Employee:work()
    print(self.name .. " is working as a " .. self.jobTitle)
end

local emp = Employee.new("Alice", 30, "Software Engineer", 80000)
emp:introduce()
emp:work()

-- Shape hierarchy with super calls
local Shape = {}
Shape.__index = Shape

function Shape.new()
    local self = setmetatable({}, Shape)
    self.color = "white"
    return self
end

function Shape:setColor(color)
    self.color = color
    print("Shape color set to " .. color)
end

function Shape:describe()
    print("This is a " .. self.color .. " shape")
end

-- Rectangle extends Shape
local Rectangle = {}
Rectangle.__index = Rectangle
setmetatable(Rectangle, {__index = Shape})

function Rectangle.new(width, height)
    local self = Shape.new()
    setmetatable(self, Rectangle)
    self.width = width
    self.height = height
    return self
end

function Rectangle:setColor(color)
    Shape.setColor(self, color)  -- Call parent method
    print("Rectangle is now " .. color)
end

function Rectangle:describe()
    Shape.describe(self)  -- Call parent method
    print("It's a " .. self.width .. "x" .. self.height .. " rectangle")
end

local rect = Rectangle.new(5, 3)
rect:setColor("blue")
rect:describe()

-- Method chaining with parent calls
local Vehicle = {}
Vehicle.__index = Vehicle

function Vehicle.new()
    local self = setmetatable({}, Vehicle)
    self.speed = 0
    return self
end

function Vehicle:accelerate(amount)
    self.speed = self.speed + amount
    print("Speed: " .. self.speed)
    return self
end

local Car = {}
Car.__index = Car
setmetatable(Car, {__index = Vehicle})

function Car.new(make)
    local self = Vehicle.new()
    setmetatable(self, Car)
    self.make = make
    return self
end

function Car:accelerate(amount)
    print(self.make .. " accelerating...")
    Vehicle.accelerate(self, amount)  -- Call parent
    return self
end

function Car:honk()
    print(self.make .. " says beep!")
    return self
end

local car = Car.new("Toyota")
car:accelerate(30):honk():accelerate(20)

Output

Click Run to execute your code

Multiple Levels of Inheritance

Create deep inheritance hierarchies:

-- Base class
local Shape = {}
Shape.__index = Shape

function Shape:new()
    local self = setmetatable({}, Shape)
    return self
end

function Shape:getArea()
    return 0
end

-- Rectangle inherits from Shape
local Rectangle = setmetatable({}, {__index = Shape})
Rectangle.__index = Rectangle

function Rectangle:new(width, height)
    local self = setmetatable({}, Rectangle)
    self.width = width
    self.height = height
    return self
end

function Rectangle:getArea()
    return self.width * self.height
end

-- Square inherits from Rectangle
local Square = setmetatable({}, {__index = Rectangle})
Square.__index = Square

function Square:new(side)
    local self = Rectangle.new(self, side, side)
    setmetatable(self, Square)
    return self
end

local square = Square:new(5)
print(square:getArea())  -- 25

Polymorphism

Different objects respond to the same method call in their own way:

local Shape = {}
Shape.__index = Shape

function Shape:new()
    return setmetatable({}, Shape)
end

function Shape:draw()
    print("Drawing a shape")
end

-- Circle
local Circle = setmetatable({}, {__index = Shape})
Circle.__index = Circle

function Circle:new(radius)
    local self = setmetatable({}, Circle)
    self.radius = radius
    return self
end

function Circle:draw()
    print("Drawing a circle with radius " .. self.radius)
end

-- Rectangle
local Rectangle = setmetatable({}, {__index = Shape})
Rectangle.__index = Rectangle

function Rectangle:new(width, height)
    local self = setmetatable({}, Rectangle)
    self.width = width
    self.height = height
    return self
end

function Rectangle:draw()
    print("Drawing a rectangle " .. self.width .. "x" .. self.height)
end

-- Polymorphism in action
local shapes = {
    Circle:new(5),
    Rectangle:new(10, 20),
    Circle:new(3)
}

for i, shape in ipairs(shapes) do
    shape:draw()  -- Each shape draws itself differently
end

-- OOP: Polymorphism in Lua

-- Polymorphism: Different objects responding to the same method call

-- Base class
local Shape = {}
Shape.__index = Shape

function Shape.new()
    local self = setmetatable({}, Shape)
    return self
end

function Shape:area()
    error("Must implement area() method")
end

function Shape:draw()
    print("Drawing a shape")
end

-- Circle
local Circle = {}
Circle.__index = Circle
setmetatable(Circle, {__index = Shape})

function Circle.new(radius)
    local self = setmetatable({}, Circle)
    self.radius = radius
    return self
end

function Circle:area()
    return math.pi * self.radius ^ 2
end

function Circle:draw()
    print("Drawing a circle with radius " .. self.radius)
end

-- Rectangle
local Rectangle = {}
Rectangle.__index = Rectangle
setmetatable(Rectangle, {__index = Shape})

function Rectangle.new(width, height)
    local self = setmetatable({}, Rectangle)
    self.width = width
    self.height = height
    return self
end

function Rectangle:area()
    return self.width * self.height
end

function Rectangle:draw()
    print("Drawing a " .. self.width .. "x" .. self.height .. " rectangle")
end

-- Triangle
local Triangle = {}
Triangle.__index = Triangle
setmetatable(Triangle, {__index = Shape})

function Triangle.new(base, height)
    local self = setmetatable({}, Triangle)
    self.base = base
    self.height = height
    return self
end

function Triangle:area()
    return 0.5 * self.base * self.height
end

function Triangle:draw()
    print("Drawing a triangle")
end

-- Polymorphic function
local function printShapeInfo(shape)
    shape:draw()
    print("Area:", shape:area())
    print()
end

-- Create different shapes
local shapes = {
    Circle.new(5),
    Rectangle.new(4, 6),
    Triangle.new(3, 4),
    Circle.new(3)
}

-- Call same method on different objects
print("=== Polymorphism Demo ===")
for i, shape in ipairs(shapes) do
    printShapeInfo(shape)
end

-- Animal polymorphism
local Animal = {}
Animal.__index = Animal

function Animal:makeSound()
    print("Some generic animal sound")
end

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

function Dog.new(name)
    local self = setmetatable({}, Dog)
    self.name = name
    return self
end

function Dog:makeSound()
    print(self.name .. " says Woof!")
end

local Cat = {}
Cat.__index = Cat
setmetatable(Cat, {__index = Animal})

function Cat.new(name)
    local self = setmetatable({}, Cat)
    self.name = name
    return self
end

function Cat:makeSound()
    print(self.name .. " says Meow!")
end

local Cow = {}
Cow.__index = Cow
setmetatable(Cow, {__index = Animal})

function Cow.new(name)
    local self = setmetatable({}, Cow)
    self.name = name
    return self
end

function Cow:makeSound()
    print(self.name .. " says Moo!")
end

-- Polymorphic behavior
local animals = {
    Dog.new("Buddy"),
    Cat.new("Whiskers"),
    Cow.new("Bessie"),
    Dog.new("Max")
}

print("=== Animal Sounds ===")
for i, animal in ipairs(animals) do
    animal:makeSound()
end

-- Payment method polymorphism
local Payment = {}
Payment.__index = Payment

function Payment:process(amount)
    error("Must implement process() method")
end

local CreditCard = {}
CreditCard.__index = CreditCard
setmetatable(CreditCard, {__index = Payment})

function CreditCard.new(cardNumber)
    local self = setmetatable({}, CreditCard)
    self.cardNumber = cardNumber
    return self
end

function CreditCard:process(amount)
    print("Processing $" .. amount .. " via Credit Card ending in " .. 
          string.sub(self.cardNumber, -4))
end

local PayPal = {}
PayPal.__index = PayPal
setmetatable(PayPal, {__index = Payment})

function PayPal.new(email)
    local self = setmetatable({}, PayPal)
    self.email = email
    return self
end

function PayPal:process(amount)
    print("Processing $" .. amount .. " via PayPal (" .. self.email .. ")")
end

local Cash = {}
Cash.__index = Cash
setmetatable(Cash, {__index = Payment})

function Cash.new()
    return setmetatable({}, Cash)
end

function Cash:process(amount)
    print("Processing $" .. amount .. " in cash")
end

-- Process payments polymorphically
local payments = {
    CreditCard.new("1234567890123456"),
    PayPal.new("user@example.com"),
    Cash.new()
}

print("\n=== Processing Payments ===")
for i, payment in ipairs(payments) do
    payment:process(100)
end

Output

Click Run to execute your code

Inheritance Helper Function

Create a reusable function to simplify inheritance:

local function class(base)
    local c = {}
    
    if base then
        setmetatable(c, {__index = base})
    end
    
    c.__index = c
    
    function c:new(...)
        local instance = setmetatable({}, c)
        if instance.init then
            instance:init(...)
        end
        return instance
    end
    
    return c
end

-- Usage
local Animal = class()

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

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

-- Dog inherits from Animal
local Dog = class(Animal)

function Dog:init(name, breed)
    Animal.init(self, name)
    self.breed = breed
end

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

local dog = Dog:new("Buddy", "Golden Retriever")
dog:speak()  -- Buddy barks!

Practical Examples

Employee Hierarchy

-- Base Employee class
local Employee = {}
Employee.__index = Employee

function Employee:new(name, salary)
    local self = setmetatable({}, Employee)
    self.name = name
    self.salary = salary
    return self
end

function Employee:getInfo()
    return self.name .. " - $" .. self.salary
end

function Employee:getBonus()
    return self.salary * 0.1  -- 10% bonus
end

-- Manager inherits from Employee
local Manager = setmetatable({}, {__index = Employee})
Manager.__index = Manager

function Manager:new(name, salary, department)
    local self = Employee.new(self, name, salary)
    setmetatable(self, Manager)
    self.department = department
    return self
end

function Manager:getBonus()
    return self.salary * 0.2  -- 20% bonus for managers
end

function Manager:getInfo()
    return Employee.getInfo(self) .. " (Manager of " .. self.department .. ")"
end

local emp = Employee:new("Alice", 50000)
local mgr = Manager:new("Bob", 80000, "Engineering")

print(emp:getInfo())  -- Alice - $50000
print(emp:getBonus())  -- 5000

print(mgr:getInfo())  -- Bob - $80000 (Manager of Engineering)
print(mgr:getBonus())  -- 16000

Vehicle Hierarchy

local Vehicle = {}
Vehicle.__index = Vehicle

function Vehicle:new(brand, model)
    local self = setmetatable({}, Vehicle)
    self.brand = brand
    self.model = model
    self.speed = 0
    return self
end

function Vehicle:accelerate(amount)
    self.speed = self.speed + amount
end

function Vehicle:getInfo()
    return self.brand .. " " .. self.model .. " - Speed: " .. self.speed
end

-- Car inherits from Vehicle
local Car = setmetatable({}, {__index = Vehicle})
Car.__index = Car

function Car:new(brand, model, doors)
    local self = Vehicle.new(self, brand, model)
    setmetatable(self, Car)
    self.doors = doors
    return self
end

function Car:honk()
    print("Beep beep!")
end

-- Motorcycle inherits from Vehicle
local Motorcycle = setmetatable({}, {__index = Vehicle})
Motorcycle.__index = Motorcycle

function Motorcycle:new(brand, model, hasWindshield)
    local self = Vehicle.new(self, brand, model)
    setmetatable(self, Motorcycle)
    self.hasWindshield = hasWindshield
    return self
end

function Motorcycle:wheelie()
    print("Doing a wheelie!")
end

local car = Car:new("Toyota", "Camry", 4)
local bike = Motorcycle:new("Harley", "Davidson", true)

car:accelerate(60)
car:honk()
print(car:getInfo())

bike:accelerate(80)
bike:wheelie()
print(bike:getInfo())

-- OOP Inheritance Hierarchy Example

-- Base class: Vehicle
Vehicle = {}
Vehicle.__index = Vehicle

function Vehicle:new(brand, model, year)
    local instance = setmetatable({}, self)
    instance.brand = brand
    instance.model = model
    instance.year = year
    instance.speed = 0
    return instance
end

function Vehicle:accelerate(amount)
    self.speed = self.speed + amount
    print(string.format("%s %s accelerating to %d km/h", 
                       self.brand, self.model, self.speed))
end

function Vehicle:brake(amount)
    self.speed = math.max(0, self.speed - amount)
    print(string.format("%s %s slowing to %d km/h", 
                       self.brand, self.model, self.speed))
end

function Vehicle:get_info()
    return string.format("%d %s %s", self.year, self.brand, self.model)
end

-- Derived class: Car
Car = setmetatable({}, {__index = Vehicle})
Car.__index = Car

function Car:new(brand, model, year, doors)
    local instance = Vehicle.new(self, brand, model, year)
    setmetatable(instance, self)
    instance.doors = doors or 4
    instance.trunk_open = false
    return instance
end

function Car:open_trunk()
    self.trunk_open = true
    print("Trunk opened")
end

function Car:close_trunk()
    self.trunk_open = false
    print("Trunk closed")
end

function Car:get_info()
    return string.format("%s (%d doors)", 
                        Vehicle.get_info(self), self.doors)
end

-- Derived class: Motorcycle
Motorcycle = setmetatable({}, {__index = Vehicle})
Motorcycle.__index = Motorcycle

function Motorcycle:new(brand, model, year, engine_cc)
    local instance = Vehicle.new(self, brand, model, year)
    setmetatable(instance, self)
    instance.engine_cc = engine_cc or 250
    instance.wheelie = false
    return instance
end

function Motorcycle:do_wheelie()
    if self.speed > 20 then
        self.wheelie = true
        print("Doing a wheelie!")
    else
        print("Need more speed for a wheelie")
    end
end

function Motorcycle:get_info()
    return string.format("%s (%dcc)", 
                        Vehicle.get_info(self), self.engine_cc)
end

-- Derived class: Truck (from Car)
Truck = setmetatable({}, {__index = Car})
Truck.__index = Truck

function Truck:new(brand, model, year, cargo_capacity)
    local instance = Car.new(self, brand, model, year, 2)
    setmetatable(instance, self)
    instance.cargo_capacity = cargo_capacity or 1000
    instance.cargo_weight = 0
    return instance
end

function Truck:load_cargo(weight)
    if self.cargo_weight + weight <= self.cargo_capacity then
        self.cargo_weight = self.cargo_weight + weight
        print(string.format("Loaded %d kg. Total: %d/%d kg", 
                           weight, self.cargo_weight, self.cargo_capacity))
        return true
    else
        print("Cannot load: exceeds capacity")
        return false
    end
end

function Truck:unload_cargo(weight)
    if self.cargo_weight >= weight then
        self.cargo_weight = self.cargo_weight - weight
        print(string.format("Unloaded %d kg. Remaining: %d kg", 
                           weight, self.cargo_weight))
        return true
    else
        print("Cannot unload: not enough cargo")
        return false
    end
end

function Truck:get_info()
    return string.format("%s (Cargo: %d/%d kg)", 
                        Vehicle.get_info(self), 
                        self.cargo_weight, self.cargo_capacity)
end

-- Test the hierarchy
print("=== Vehicle Hierarchy Demo ===\n")

-- Create vehicles
local sedan = Car:new("Toyota", "Camry", 2023, 4)
local bike = Motorcycle:new("Harley", "Sportster", 2022, 883)
local pickup = Truck:new("Ford", "F-150", 2023, 1500)

-- Test Car
print("--- Car ---")
print(sedan:get_info())
sedan:accelerate(50)
sedan:open_trunk()
sedan:brake(20)
print()

-- Test Motorcycle
print("--- Motorcycle ---")
print(bike:get_info())
bike:accelerate(30)
bike:do_wheelie()  -- Too slow
bike:accelerate(20)
bike:do_wheelie()  -- Fast enough
print()

-- Test Truck
print("--- Truck ---")
print(pickup:get_info())
pickup:load_cargo(500)
pickup:load_cargo(800)
pickup:accelerate(40)
pickup:unload_cargo(300)
print(pickup:get_info())
print()

-- Demonstrate polymorphism
print("--- Polymorphism ---")
local vehicles = {sedan, bike, pickup}

for i, vehicle in ipairs(vehicles) do
    print(string.format("%d. %s", i, vehicle:get_info()))
end

print("\n--- All vehicles accelerating ---")
for _, vehicle in ipairs(vehicles) do
    vehicle:accelerate(30)
end

Output

Click Run to execute your code

Practice Exercise

Try these inheritance challenges:

-- Exercise: Inheritance
-- TODO: Complete the following exercises

-- 1. Create a Vehicle base class and Car derived class
local Vehicle = {}
Vehicle.__index = Vehicle

function Vehicle.new(make, model)
    -- your code here
end

function Vehicle:start()
    -- your code here
end

local Car = {}
Car.__index = Car
setmetatable(Car, {__index = Vehicle})

function Car.new(make, model, doors)
    -- your code here
    -- call parent constructor
end

function Car:honk()
    -- your code here
end

-- local car = Car.new("Toyota", "Camry", 4)
-- car:start()  -- Should work (inherited)
-- car:honk()   -- Should work (own method)

-- 2. Create Shape, Rectangle, and Circle with area() method
local Shape = {}
Shape.__index = Shape

function Shape.new()
    -- your code here
end

function Shape:area()
    -- your code here
    -- should error or return 0
end

local Rectangle = {}
Rectangle.__index = Rectangle
setmetatable(Rectangle, {__index = Shape})

function Rectangle.new(width, height)
    -- your code here
end

function Rectangle:area()
    -- your code here
end

local Circle = {}
Circle.__index = Circle
setmetatable(Circle, {__index = Shape})

function Circle.new(radius)
    -- your code here
end

function Circle:area()
    -- your code here
end

-- local rect = Rectangle.new(5, 3)
-- local circle = Circle.new(4)
-- print("Rectangle area:", rect:area())
-- print("Circle area:", circle:area())

-- 3. Create Employee that extends Person
local Person = {}
Person.__index = Person

function Person.new(name, age)
    -- your code here
end

function Person:introduce()
    -- your code here
end

local Employee = {}
Employee.__index = Employee
setmetatable(Employee, {__index = Person})

function Employee.new(name, age, jobTitle)
    -- your code here
    -- call parent constructor
end

function Employee:introduce()
    -- your code here
    -- call parent introduce, then add job info
end

-- local emp = Employee.new("Alice", 30, "Developer")
-- emp:introduce()

-- 4. Create polymorphic animals
local Animal = {}
Animal.__index = Animal

function Animal:makeSound()
    -- your code here
end

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

function Dog.new(name)
    -- your code here
end

function Dog:makeSound()
    -- your code here (Woof!)
end

local Cat = {}
Cat.__index = Cat
setmetatable(Cat, {__index = Animal})

function Cat.new(name)
    -- your code here
end

function Cat:makeSound()
    -- your code here (Meow!)
end

-- local animals = {Dog.new("Buddy"), Cat.new("Whiskers")}
-- for i, animal in ipairs(animals) do
--     animal:makeSound()
-- end

Output

Click Run to execute your code

Summary

In this lesson, you learned:

Creating inheritance using metatables and __index
Calling parent methods (super) from child classes
Building multiple levels of inheritance
Implementing polymorphism for flexible code
Creating inheritance helper functions
Practical examples: Employee and Vehicle hierarchies

What's Next?

You've mastered inheritance in Lua! Next, we'll explore modules—how to organize your code into reusable packages, manage dependencies, and create clean APIs. Let's continue! 🚀

Previous OOP Basics

Next Modules

Basic Inheritance

Calling Parent Methods (Super)

Multiple Levels of Inheritance

Polymorphism

Inheritance Helper Function

Practical Examples

Employee Hierarchy

Vehicle Hierarchy

Practice Exercise

Summary

What's Next?

Enjoying these tutorials?