Lua - Programmation Orientée Objet

Introduction à la POO

Salut à toi, futur(e) programmeur(euse) ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde de la Programmation Orientée Objet (POO) en utilisant Lua. Ne t'inquiète pas si tu es nouveau dans le domaine de la programmation ; je vais te guider étape par étape avec le même soin et l'enthousiasme que j'utilise dans mes cours depuis des années.

La Programmation Orientée Objet est comme construire avec des briques LEGO. Chaque brique (ou objet) a ses propres propriétés et peut effectuer certaines actions. Quand nous les assemblons, nous créons des structures incroyables (ou des programmes) !

Caractéristiques de la POO

Avant de plonger dans Lua, examinons rapidement les principales caractéristiques de la POO :

1. Encapsulation : C'est comme garder tes jouets dans une boîte. La boîte (objet) contient toutes les choses liées (données et fonctions).
2. Héritage : Imagine que tu as un jouet robot. Maintenant, tu obtiens un nouveau jouet robot qui peut faire tout ce que l'ancien pouvait faire, plus quelques nouveaux tours. C'est l'héritage !
3. Polymorphisme : C'est comme avoir une télécommande qui fonctionne pour différents appareils. Même bouton, différentes actions selon ce que tu contrôles.
4. Abstraction : Pense à cela comme utiliser un micro-ondes. Tu n'as pas besoin de savoir comment il fonctionne à l'intérieur ; tu as seulement besoin de savoir quelles touches presser.

POO en Lua

Maintenant, voyons comment nous pouvons utiliser ces concepts de POO en Lua. Lua n'a pas de classes intégrées comme d'autres langages, mais nous pouvons créer des structures orientées objet en utilisant des tables et des fonctions. C'est comme construire notre propre ensemble LEGO à partir de zéro !

Création d'une Classe Simple

Commençons par créer une classe simple. En Lua, nous utilisons des tables pour représenter les classes.

local Dog = {}
Dog.__index = Dog

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

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

Décomposons cela :

1. Nous créons une table appelée Dog.
2. Nous définissons Dog.__index = Dog. C'est un peu de magie Lua qui aide avec l'héritage.
3. Nous créons une fonction new qui agit comme notre constructeur. Elle crée un nouveau chien avec un nom et un âge.
4. Nous ajoutons une méthode bark à notre classe Dog.

Création d'un Objet

Maintenant que nous avons notre classe Dog, créons un objet Dog :

local myDog = Dog.new("Buddy", 3)

Félicitations ! Tu viens de créer ton premier objet. myDog est maintenant un objet Dog avec le nom "Buddy" et l'âge 3.

Accès aux Propriétés

Nous pouvons accéder aux propriétés de notre chien comme ceci :

print(myDog.name) -- Affiche : Buddy
print(myDog.age)  -- Affiche : 3

C'est aussi simple que d'utiliser la notation pointée !

Accès aux Fonctions Membres

Pour faire criquer notre chien, nous pouvons appeler la méthode bark :

myDog:bark() -- Affiche : Buddy dit : Woof !

Notez l'utilisation du deux-points : au lieu d'un point. C'est la façon de Lua de passer self à la méthode.

Exemple Complet

Mettons tout cela ensemble :

local Dog = {}
Dog.__index = Dog

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

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

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

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

function Labrador:swim()
print(self.name .. " est en train de nager !")
end

Ici, nous créons une classe Labrador qui hérite de Dog. Elle a toutes les propriétés et méthodes de Dog, plus une nouvelle propriété (couleur) et une nouvelle méthode (nager).

Remplacement de Fonctions de Base

Nous pouvons également surcharger des fonctions de la classe de base. Donnons à notre Labrador un aboiement spécial :

function Labrador:bark()
print(self.name .. " dit : Woof woof woof !")
end

Maintenant, quand un Labrador aboie, ce sera différent d'un chien régulier.

Exemple Complet d'Héritage

Mettons tout cela ensemble :

local Dog = {}
Dog.__index = Dog

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

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

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

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

function Labrador:swim()
print(self.name .. " est en train de nager !")
end

function Labrador:bark()
print(self.name .. " dit : Woof woof woof !")
end

local myDog = Dog.new("Buddy", 3)
local myLabrador = Labrador.new("Max", 2, " Jaune")

myDog:bark()      -- Affiche : Buddy dit : Woof !
myLabrador:bark() -- Affiche : Max dit : Woof woof woof !
myLabrador:swim() -- Affiche : Max est en train de nager !

Et voilà ! Nous avons créé une structure de classe de base, implémenté l'héritage, et même surchargé des méthodes. Tu es bien sur le chemin pour devenir un expert de la POO en Lua !

Souviens-toi, la pratique rend parfait. Essaie de créer tes propres classes et expérimente avec différentes propriétés et méthodes. Bonne programmation !

Credits: Image by storyset