Comment créer une classe, sous-classe et les propriétés en Lua?

Voici un exemple transcription littérale de votre code, avec un utile Class bibliothèque qui peut être déplacé vers un autre fichier.

Ce n'est pas une représentation canonique de la mise en œuvre de Class; n'hésitez pas à définir votre modèle d'objet comme vous le souhaitez.

Class = {}
function Class:new(super)
local class, metatable, properties = {}, {}, {}
class.metatable = metatable
class.properties = properties
function metatable:__index(key)
local prop = properties[key]
if prop then
return prop.get(self)
elseif class[key] ~= nil then
return class[key]
elseif super then
return super.metatable.__index(self, key)
else
return nil
end
end
function metatable:__newindex(key, value)
local prop = properties[key]
if prop then
return prop.set(self, value)
elseif super then
return super.metatable.__newindex(self, key, value)
else
rawset(self, key, value)
end
end
function class:new(...)
local obj = setmetatable({}, self.metatable)
if obj.__new then
obj:__new(...)
end
return obj
end
return class
end
ElectronicDevice = Class:new()
function ElectronicDevice:__new()
self.isOn = false
end
ElectronicDevice.properties.isOn = {}
function ElectronicDevice.properties.isOn:get()
return self._isOn
end
function ElectronicDevice.properties.isOn:set(value)
self._isOn = value
end
function ElectronicDevice:Reboot()
self._isOn = false
self:ResetHardware()
self._isOn = true
end
Router = Class:new(ElectronicDevice)
Modem = Class:new(ElectronicDevice)
function Modem:WarDialNeighborhood(areaCode)
local cisco = Router:new()
cisco:Reboot()
self:Reboot()
if self._isOn then
self:StartDialing(areaCode)
end
end

Si vous étiez à coller aux méthodes get/set pour les propriétés, vous n'auriez pas besoin __index et __newindex fonctions, et pourrait juste avoir un __index table. Dans ce cas, la façon la plus simple de simuler l'héritage est quelque chose comme ceci:

BaseClass = {}
BaseClass.index = {}
BaseClass.metatable = {__index = BaseClass.index}
DerivedClass = {}
DerivedClass.index = setmetatable({}, {__index = BaseClass.index})
DerivedClass.metatable = {__index = DerivedClass.index}

En d'autres termes, la classe dérivée de __index table "hérite" de la classe de base __index table. Cela fonctionne parce que Lua, lors de déléguer à un __index table, effectivement répète la recherche sur elle, de sorte que le __index table metamethods sont invoqués.

Méfiez-vous également sur l'appel de obj.Method(...) vs obj:Method(...). obj:Method(...) est sucre syntaxique pour obj.Method(obj, ...), et mélanger les deux appels peuvent produire des erreurs.

Si vous ne voulez pas de réinventer la roue, il y a une belle bibliothèque Lua la mise en œuvre de plusieurs modèles d'objet. Il est appelé BOUCLE.

Mise à jour de votre code est verbeux, mais devrait fonctionner. Sauf, vous avez une faute de frappe c'est la rupture de l'un des metatables:

--Modem hérite de ElectronicDevice 
Modem = setmetatable({},{__index,ElectronicDevice}); 

devrait lire

--Modem hérite de ElectronicDevice 
Modem = setmetatable({},{__index=ElectronicDevice}); 

L'existant fragment fait le Modem métatable être un tableau dont le premier élément est presque certainement néant (la valeur habituelle de _G.__index sauf si vous utilisez strict.lua ou quelque chose de similaire) et le deuxième élément est ElectronicDevice.

La Lua Wiki description du sens, après que vous avez grokked metatables un peu plus. Une chose qui aide est de construire un peu d'infrastructures pour faire les schémas habituels plus facile pour obtenir le droit.

Je recommande aussi la lecture du chapitre sur la programmation orientée objet en PiL. Vous aurez envie de relire les chapitres sur les tables et les metatables trop. Aussi, je suis lié à la copie en ligne de la 1ère édition, mais la possession d'une copie de la 2ème est fortement recommandé. Il y a aussi quelques articles dans la Lua Gemmes livre qui se rapportent. Il est aussi recommandé.

Une autre approche simple pour la sous-classe

local super    = require("your base class")
local newclass = setmetatable( {}, {__index = super } )
local newclass_mt = { __index = newclass }
function newclass.new(...) -- constructor
local self = super.new(...)
return setmetatable( self, newclass_mt )
end

Vous pouvez toujours utiliser les fonctions de super-classe, même s'il a été écrasé

function newclass:dostuff(...)
super.dostuff(self,...)
-- more code here --
end

n'oubliez pas d'utiliser UN point quand il passe de l'auto à la super-classe de la fonction