Lua 面向对象

La programmation orientée objet (Object-Oriented Programming, OOP) est une architecture de programmation informatique très populaire.

Les suivantes sont des langages de programmation qui supportent la programmation orientée objet :

• C++

• Java

• Objective-C

• Smalltalk

• C#

• Ruby

Caractéristiques orientées objet

• 1） Encapsulation : Il s'agit de la capacité de regrouper les informations, les fonctionnalités et les réponses d'un seul objet dans un seul objet.

• 2） Héritage : La méthode d'héritage permet d'élargir le programme sans le modifier, ce qui permet de conserver les fonctionnalités originales tout en étendant les nouvelles fonctionnalités. Cela favorise la réduction du codage redondant et l'augmentation de l'efficacité du développement de logiciels.

• 3） Polymorphisme : La même opération agit sur des objets différents, peut avoir différentes interprétations et produire des résultats d'exécution différents. Au cours de l'exécution, il est possible d'appeler des méthodes de la classe dérivée à partir d'un pointeur vers la classe de base.

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

Programmation orientée objet en Lua

Nous savons que les objets sont composés de propriétés et de méthodes. Le structure la plus élémentaire en LUA est le tableau, donc il faut utiliser le tableau pour décrire les propriétés des objets.

Les fonctions en lua peuvent être utilisées pour représenter des méthodes. Alors, les classes en LUA peuvent être représentées par des tableaux + function simuler.

En ce qui concerne l'héritage, il peut être simulé par le metatable (n'est pas recommandé, il suffit généralement de simuler les objets de base les plus simples).

Les tableaux en Lua ne sont pas seulement une sorte d'objet dans un certain sens. Comme les objets, les tableaux ont un état (variables membres) ; ils ont également une nature indépendante de la valeur de l'objet, en particulier, deux objets (tableaux) représentant deux objets différents avec deux valeurs différentes ; un objet peut avoir différentes valeurs à différents moments, mais il reste toujours un objet ; comme les objets, la durée de vie des tableaux n'a rien à voir avec ce qui les crée ou où ils sont créés. Les objets ont leurs fonctions membres, et les tableaux en ont aussi :

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

Cette définition crée une nouvelle fonction et la conserve dans le domaine withdraw de l'objet Account, nous pouvons l'appeler ainsi :

Account.withdraw (100.00)

Un exemple simple

Voici une classe simple qui contient trois propriétés : area, length et breadth, la méthode printArea est utilisée pour imprimer le résultat du calcul :

--　méta-classe
Rectangle = {area = 0, length = 0, breadth = 0}
--　méthode de classe dérivée new
function　Rectangle:new　(o,length,breadth)
　　o = o or {}
　　setmetatable(o,　self)
　　self.__index　=　self
　　self.length = length or 0
　　self.breadth = largeur or 0
　　self.area　=　length*largeur;
　　return　o
end
--　méthode de classe dérivée printArea
function　Rectangle:printArea　()
　　print("矩形面积为　",self.area)
end

创建对象

La création d'un objet est le processus d'allouer de la mémoire pour l'exemple de la classe. Chaque classe a sa propre mémoire et partage les données communes.

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

Accéder aux propriétés

Nous pouvons utiliser le point . pour accéder aux propriétés de la classe :

print(r.length)

Accéder aux fonctions membres

Nous pouvons utiliser le deux-points : pour accéder aux fonctions membres de la classe :

r:printArea ()

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

Exemple complet

Dans ce qui suit, nous démontrons un exemple complet d'orientation objet Lua :

--　méta-classe
Shape = {area = 0}
--　méthode de classe de base 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
--　méthode de classe de base printArea
function Shape:printArea ()
　　print("面积为　",self.area)
end
--　创建对象
myshape　=　Shape:new(nil,10)
myshape:printArea()

En exécutant le programme ci-dessus, le résultat est :

面积为　　　　　100

Héritage Lua

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

Voici un exemple simple d'héritage :

--　classe métamorphique
Shape = {area = 0}
--　méthode de classe de base 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
--　méthode de classe de base printArea
function Shape:printArea ()
　　print("面积为　",self.area)
end

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

Square　=　Shape:new()
--　méthode de classe dérivée new
function　Square:new　(o,side)
　　o　=　o　or　Shape:new(o,side)
　　setmetatable(o,　self)
　　self.__index　=　self
　　return　o
end

Exemple complet

Dans l'exemple suivant, nous avons hérité 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 héritées :

--　classe métamorphique
Shape = {area = 0}
--　méthode de classe de base 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
--　méthode de classe de base 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()

执行以上代码，输出结果为：

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

函数重写

Lua 中我们可以重写基础类的函数，在派生类中定义自己的实现方式：

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