0Pricing
Lua Academy · Leçon

Appeler les méthodes parentes avec super

Appelez explicitement les méthodes de la classe de base pour une initialisation coopérative.

Appeler les méthodes parentes avec super est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Pourquoi appeler le parent ?

Lorsqu'un enfant redéfinit une méthode parente tout en ayant besoin de la logique du parent, il appelle explicitement la méthode parente. Lua ne possède pas de mot-clé super : référencez directement la table parente : Parent.method(self, args).

local Base={}
Base.__index=Base
function Base:describe()
  return "Base[name="..self.name.."]"
end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})

function Child:describe()
  local parentDesc = Base.describe(self)  -- super call
  return parentDesc .. " + Child[extra=true]"
end

local c=setmetatable({name="X"},Child)
print(c:describe())

Appel du parent dans le constructeur

Les constructeurs enfants appellent les constructeurs parents via Parent.new() ou Parent._init(self,...). Cela garantit que l'initialisation du parent s'exécute pour chaque instance enfant.

local Animal={}
Animal.__index=Animal
function Animal._init(self,name,sound)
  self.name=name; self.sound=sound; self.alive=true
end

local Dog={}
Dog.__index=Dog; setmetatable(Dog,{__index=Animal})
function Dog.new(name,breed)
  local self=setmetatable({},Dog)
  Animal._init(self,name,"Woof")  -- super init
  self.breed=breed
  return self
end

local d=Dog.new("Rex","Lab")
print(d.name,d.sound,d.breed)

Initialisation coopérative

Dans les hiérarchies profondes, chaque niveau initialise uniquement ses propres champs et appelle l'initialisation du parent. Ainsi, chaque classe reste responsable de ses propres champs.

local A={}
function A._init(self,x) self.x=x end

local B={}
function B._init(self,x,y) A._init(self,x); self.y=y end

local C={}
C.__index=C
function C.new(x,y,z)
  local self=setmetatable({},C)
  B._init(self,x,y)
  self.z=z
  return self
end

local c=C.new(1,2,3)
print(c.x,c.y,c.z)  -- 1 2 3

Enveloppe super

Créez un assistant super(self) qui renvoie un objet proxy appelant les méthodes parentes avec self. Vous obtenez ainsi une syntaxe plus claire que Parent.method(self, ...).

local function super(self)
  local mt = getmetatable(getmetatable(self).__index)
  if mt then
    return setmetatable({}, {__index=function(_,k)
      local parentCls = mt.__index or mt
      return function(...) return parentCls[k](self,...) end
    end})
  end
end
print("super() helper pattern shown")

Plusieurs niveaux

Lorsqu'il existe plusieurs niveaux d'héritage, chaque niveau appelle son parent immédiat. La chaîne se propage automatiquement.

local L1={} L1.__index=L1
function L1:intro() return "L1" end

local L2={} L2.__index=L2
setmetatable(L2,{__index=L1})
function L2:intro() return L1.intro(self).."+L2" end

local L3={} L3.__index=L3
setmetatable(L3,{__index=L2})
function L3:intro() return L2.intro(self).."+L3" end

local obj=setmetatable({},L3)
print(obj:intro())  -- L1+L2+L3

Enrichissement de méthodes

Enrichissez une méthode parente : appelez la version parente, puis ajoutez un comportement supplémentaire. Il s'agit d'un conseil « avant » ou « après », sans structure AOP formelle.

local Logger={} Logger.__index=Logger
function Logger:log(msg) print("[LOG] "..msg) end

local TimedLogger={} TimedLogger.__index=TimedLogger
setmetatable(TimedLogger,{__index=Logger})

function TimedLogger:log(msg)
  local ts=os.date("%H:%M:%S")
  Logger.log(self,"["..ts.."] "..msg)  -- augment
end

local tl=setmetatable({},TimedLogger)
tl:log("Server started")

Éviter les pièges des appels au parent

Utilisez toujours le nom exact de la classe parente, et non getmetatable(self).__index, pour les appels au parent : la recherche dans la métatable peut renvoyer une classe intermédiaire, et non le véritable parent. Soyez explicite pour préserver la clarté et la justesse.

-- Correct: explicit parent reference
function Child:init(x)
  Base.init(self, x)  -- explicit, clear
end

-- Fragile: uses metatable lookup
function Child:initBad(x)
  local parent = getmetatable(getmetatable(self).__index)
  -- This may not be Base if hierarchy changes!
end
print("Be explicit with parent class references")

super pour __tostring

Redéfinissez __tostring dans un enfant tout en incluant la représentation du parent afin d'obtenir une description complète.

local Base={}
Base.__index=Base
Base.__tostring=function(self) return "Base("..self.name..")" end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
Child.__tostring=function(self)
  local baseStr = Base.__tostring(self)
  return baseStr.." + Child(level="..self.level..")"
end

local c=setmetatable({name="X",level=5},Child)
print(tostring(c))  -- Base(X) + Child(level=5)

Méthode modèle protégée

Le modèle de méthode modèle : la classe de base définit l'ossature d'un algorithme en appelant des étapes abstraites ; les sous-classes implémentent ces étapes.

local Processor={} Processor.__index=Processor
function Processor:run(data)
  data = self:preProcess(data)
  data = self:process(data)
  return self:postProcess(data)
end
function Processor:preProcess(d) return d end
function Processor:postProcess(d) return d end
function Processor:process(d) error("implement process()") end

local Upper={} Upper.__index=Upper
setmetatable(Upper,{__index=Processor})
function Upper:process(d) return d:upper() end

local p=setmetatable({},Upper)
print(p:run("hello"))  -- HELLO

Convention d'appel du parent

Convention : préfixez les fonctions d'initialisation internes avec _ (par exemple _init) et n'exposez un new() public qu'au niveau du constructeur de haut niveau. Cela préserve la clarté de la chaîne d'héritage.

-- Convention summary:
-- Animal._init(self, ...)  -- used for super calls
-- Dog.new(...)             -- only public constructor
-- Never call Dog._init from outside

local Foo={} Foo.__index=Foo
function Foo._init(self,x) self.x=x end
function Foo.new(x)
  return setmetatable({},Foo):_init(x) or
    (function() local s=setmetatable({},Foo); Foo._init(s,x); return s end)()
end
print("Convention: _init for super, new() for public")

Question sur l'appel du parent

Comment appelez-vous une méthode parente en Lua ?

Récapitulatif : appels au parent

Appelez toujours les méthodes parentes en référençant explicitement la classe : Parent.method(self, ...). Utilisez la convention _init pour les constructeurs coopératifs à travers les différents niveaux d'héritage.

Questions Fréquemment Posées

La leçon « Appeler les méthodes parentes avec super » est-elle gratuite ?

Oui — le texte complet de « Appeler les méthodes parentes avec super » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Appeler les méthodes parentes avec super » ?

Appelez explicitement les méthodes de la classe de base pour une initialisation coopérative. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Appeler les méthodes parentes avec super » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Héritage simple avec chaînage de __index
  2. Appeler les méthodes parentes avec super
  3. Modèles de mixins
  4. Redéfinition et polymorphisme
← Retour à Lua Academy