Lua orienté objet


La programmation orientée objet (POO) est une architecture de programmation informatique très populaire.

Les langages de programmation suivants prennent en charge la programmation orientée objet :


  • C++

  • Java

  • Objective-C

  • Smalltalk

  • C#

  • Ruby

Fonctionnalités orientées objet

  • 1) Encapsulation : fait référence à la capacité d'encapsuler le les informations, les fonctions et les attributs de réponse sont chargés dans un objet séparé.

  • 2) Héritage : La méthode d'héritage permet d'étendre le programme d'origine sans le modifier, afin que les fonctions d'origine puissent être préservées et que de nouvelles fonctions puissent être étendues. Cela permet de réduire le codage répété et d’améliorer l’efficacité du développement logiciel.

  • 3) Polymorphisme : La même opération agit sur différents objets et peut avoir différentes interprétations et produire des résultats d'exécution différents. Au moment de l'exécution, vous pouvez appeler des méthodes dans une classe dérivée via un pointeur vers la classe de base.

  • 4) Abstraction : L'abstraction est un moyen de simplifier des problèmes complexes de la vie réelle. Elle peut trouver la définition de classe la plus appropriée pour des problèmes spécifiques et l'expliquer au niveau d'héritage le plus approprié. .

Orienté objet en Lua

Nous savons que les objets sont composés de propriétés et de méthodes. La structure la plus basique de LUA est le tableau, le tableau doit donc être utilisé pour décrire les propriétés des objets.

La fonction en Lua peut être utilisée pour représenter des méthodes. Ensuite, les classes en LUA peuvent être simulées via table + fonction.

Quant à l'héritage, il peut être simulé via metetable (non recommandé, seule la simulation des objets les plus basiques suffit la plupart du temps).


Une table en Lua n'est pas seulement un objet dans un certain sens. Comme les objets, les tables ont aussi des états (variables membres) ; elles ont aussi la nature d'être indépendantes des valeurs des objets. En particulier, un objet (table) avec deux valeurs différentes peut représenter deux objets différents ; ont également des valeurs différentes à des moments différents, mais c'est toujours un objet ; semblable à un objet, le cycle de vie d'une table n'a rien à voir avec ce à partir de quoi elle est créée et où elle est créée. Les objets ont leurs fonctions membres, et les tables ont aussi : 

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

Cette définition crée une nouvelle fonction et l'enregistre dans le champ de retrait de l'objet Compte Ci-dessous, nous pouvons l'appeler ainsi : 

Account.withdraw(100.00)
<🎜. >Un exemple simple

La classe simple suivante contient trois attributs : surface, longueur et largeur. La méthode printArea est utilisée pour imprimer les résultats du calcul : 

-- Meta class
Rectangle = {area = 0, length = 0, breadth = 0}

-- 派生类的方法 new
function Rectangle:new (o,length,breadth)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  self.length = length or 0
  self.breadth = breadth or 0
  self.area = length*breadth;
  return o
end

-- 派生类的方法 printArea
function Rectangle:printArea ()
  print("矩形面积为 ",self.area)
end

Créer un objet

. Créer un objet est le processus d'allocation de mémoire pour les instances d'une classe. Chaque classe possède sa propre mémoire et partage des données communes. 

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

Accès aux attributs

On peut utiliser le point (.) pour accéder aux attributs d'une classe : 

print(r.length)

Accès aux fonctions membres

On peut utiliser les deux points ( :) pour accéder aux propriétés d'une classe : 

r:printArea()

La mémoire est allouée lors de l'initialisation de l'objet.

Exemple complet

Ci-dessous, nous démontrons un exemple complet de Lua orienté objet : 

-- Meta class
Shape = {area = 0}

-- 基础类方法 new
function Shape:new (o,side)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  side = side or 0
  self.area = side*side;
  return o
end

-- 基础类方法 printArea
function Shape:printArea ()
  print("面积为 ",self.area)
end

-- 创建对象
myshape = Shape:new(nil,10)

myshape:printArea()

Exécutez le programme ci-dessus, le résultat de sortie est : 

面积为 	100

Héritage Lua

L'héritage signifie qu'un objet utilise directement les propriétés et les méthodes d'un autre objet. Propriétés et méthodes pouvant être utilisées pour étendre la classe de base.

Ce qui suit montre un exemple d'héritage simple : 

 -- Meta class
Shape = {area = 0}
-- 基础类方法 new
function Shape:new (o,side)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  side = side or 0
  self.area = side*side;
  return o
end
-- 基础类方法 printArea
function Shape:printArea ()
  print("面积为 ",self.area)
end

L'exemple suivant, l'objet Square hérite de la classe Shape : 

Square = Shape:new()
-- Derived class method new
function Square:new (o,side)
  o = o or Shape:new(o,side)
  setmetatable(o, self)
  self.__index = self
  return o
end

L'exemple complet

Le Exemple suivant : Nous héritons d'une classe simple pour étendre les méthodes de la classe dérivée. La classe dérivée conserve les variables membres et les méthodes de la classe héritée : 

 -- Meta class
Shape = {area = 0}
-- 基础类方法 new
function Shape:new (o,side)
  o = o or {}
  setmetatable(o, self)
  self.__index = self
  side = side or 0
  self.area = side*side;
  return o
end
-- 基础类方法 printArea
function Shape:printArea ()
  print("面积为 ",self.area)
end

-- 创建对象
myshape = Shape:new(nil,10)
myshape:printArea()

Square = Shape:new()
-- 派生类方法 new
function Square:new (o,side)
  o = o or Shape:new(o,side)
  setmetatable(o, self)
  self.__index = self
  return o
end

-- 派生类方法 printArea
function Square:printArea ()
  print("正方形面积为 ",self.area)
end

-- 创建对象
mysquare = Square:new(nil,10)
mysquare:printArea()

Rectangle = Shape:new()
-- 派生类方法 new
function Rectangle:new (o,length,breadth)
  o = o or Shape:new(o)
  setmetatable(o, self)
  self.__index = self
  self.area = length * breadth
  return o
end

-- 派生类方法 printArea
function Rectangle:printArea ()
  print("矩形面积为 ",self.area)
end

-- 创建对象
myrectangle = Rectangle:new(nil,10,20)
myrectangle:printArea()

Exécutez le code ci-dessus et le résultat de sortie est : 

面积为 	100
正方形面积为 	100
矩形面积为 	200

Réécriture de fonctions

En Lua nous pouvons réécrire les fonctions de la classe de base et définir notre propre implémentation dans la classe dérivée : 

-- 派生类方法 printArea
function Square:printArea ()
  print("正方形面积 ",self.area)
end