Lua Academy · Leçon

Héritage simple avec chaînage de __index

Définissez une classe parente comme __index d’une métatable afin d’hériter de ses méthodes.

Héritage simple avec chaînage de __index est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Chaîne de prototypes

L'héritage simple fonctionne en définissant le __index d'une classe enfant sur la classe parente. Lorsqu'une méthode n'est pas trouvée dans l'enfant, Lua la recherche dans le parent. Cela crée une chaîne de prototypes.

local Base={}
Base.__index=Base
function Base.new() return setmetatable({},Base) end
function Base:greet() print("Hello from Base") end

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

function Child.new() return setmetatable({},Child) end

local c=Child.new()
c:greet()  -- Hello from Base (inherited)

Ordre de résolution des méthodes

Lors de l'appel d'une méthode sur une instance : (1) recherche dans la table de l'instance, (2) recherche dans Child (via __index), (3) recherche dans Base (via le __index de la métatable de Child). La première correspondance l'emporte.

local Base={}
Base.__index=Base
function Base:who() print("I am Base") end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:who() print("I am Child") end  -- override

local b=setmetatable({},Base)
local c=setmetatable({},Child)
b:who()  -- I am Base
c:who()  -- I am Child (overrides)

Héritage des constructeurs

Les classes enfants peuvent réutiliser les constructeurs parents en les appelant, ou définir les leurs afin de compléter l'initialisation du parent.

local Animal={}
Animal.__index=Animal
function Animal.new(name,sound)
  return setmetatable({name=name,sound=sound},Animal)
end
function Animal:speak() print(self.name..": "..self.sound) end

local Dog={}
Dog.__index=Dog
setmetatable(Dog,{__index=Animal})

function Dog.new(name)
  local self = Animal.new(name,"Woof")
  return setmetatable(self,Dog)
end
function Dog:fetch(item) print(self.name.." fetches "..item) end

local d=Dog.new("Rex")
d:speak(); d:fetch("ball")

Vérification de l'ascendance

Remontez la chaîne des métatables pour vérifier si la classe d'un objet hérite d'une base donnée. C'est ainsi que fonctionne instanceof en Lua.

local function instanceof(obj, cls)
  local mt = getmetatable(obj)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end

Appel du parent

Appelez la version parente d'une méthode redéfinie en y accédant directement via la table de la classe parente.

local Base={}
Base.__index=Base
function Base:init(x) self.x=x end
function Base:value() return self.x end

local Child={}
Child.__index=Child
setmetatable(Child,{__index=Base})
function Child:init(x,y)
  Base.init(self,x)  -- call parent
  self.y=y
end
function Child:value() return Base.value(self)+self.y end

local c=setmetatable({},Child)
c:init(3,4)
print(c:value())  -- 7

Chaîne profonde

Construisez une hiérarchie à trois niveaux : A → B → C. La recherche d'une méthode parcourt toute la chaîne jusqu'à trouver la méthode.

local A={}
A.__index=A
function A:aMethod() print("A method") end

local B={}
B.__index=B
setmetatable(B,{__index=A})
function B:bMethod() print("B method") end

local C={}
C.__index=C
setmetatable(C,{__index=B})

local c=setmetatable({},C)
c:bMethod()  -- from B
c:aMethod()  -- from A

Redéfinition des champs

Une instance peut redéfinir des champs de niveau classe en les définissant directement. Le champ de la classe n'est pas modifié : il est simplement masqué pour cette instance.

local Creature={}
Creature.__index=Creature
Creature.hp=100
Creature.speed=10

function Creature.new()
  return setmetatable({},Creature)
end

local fast=Creature.new()
fast.speed=20  -- override for this instance

local normal=Creature.new()

print(fast.speed,normal.speed,Creature.speed)  -- 20  10  10

Héritage au niveau des classes

Définir setmetatable(Child, {__index=Parent}) fait remonter les recherches au niveau de la classe vers le parent. Ainsi, Child.classMethod() trouve les méthodes de la classe parente si elles ne sont pas redéfinies.

local Vehicle={}
Vehicle.__index=Vehicle
Vehicle.maxSpeed=120
function Vehicle.describe() print("Vehicle") end

local Car={}
Car.__index=Car
setmetatable(Car,{__index=Vehicle})

Car.describe()  -- Vehicle (inherited class method)
print(Car.maxSpeed)  -- 120 (inherited class field)

Chaîne d'initialisation

Pour assurer une initialisation correcte, les constructeurs enfants appellent les constructeurs parents afin de garantir la mise en place de l'état parent. Faites remonter l'initialisation dans la hiérarchie.

local Base={}
Base.__index=Base
function Base:_init(name) self.name=name end

local Mid={}
Mid.__index=Mid
setmetatable(Mid,{__index=Base})
function Mid:_init(name,level)
  Base._init(self,name)
  self.level=level
end

local Top={}
Top.__index=Top
setmetatable(Top,{__index=Mid})
function Top.new(name,level,role)
  local self=setmetatable({},Top)
  Mid._init(self,name,level)
  self.role=role
  return self
end

local t=Top.new("Alice",5,"admin")
print(t.name,t.level,t.role)

Classes de base abstraites

Créez une classe de base dont les méthodes non implémentées déclenchent une erreur. Les sous-classes doivent redéfinir ces méthodes. Cela impose les contrats d'interface dans le système de types dynamiques de Lua.

local Serializer={}
Serializer.__index=Serializer
function Serializer:encode(data)
  error(self._type.." must implement encode()",2)
end
function Serializer:decode(str)
  error(self._type.." must implement decode()",2)
end

local JSONSerializer={_type="JSON"}
setmetatable(JSONSerializer,{__index=Serializer})
function JSONSerializer:encode(data)
  return "{"..tostring(data.key).."}"
end

local j=setmetatable({_type="JSON"},JSONSerializer)
print(j:encode({key="val"}))

Question sur l'héritage

Qu'est-ce qui permet l'héritage simple en Lua ?

Récapitulatif : héritage simple

Définissez setmetatable(Child, {__index = Parent}) pour hériter des méthodes. La chaîne __index fournit une délégation automatique. Redéfinissez une méthode en la définissant dans Child ; appelez explicitement le parent avec Parent.method(self).

Questions Fréquemment Posées

La leçon « Héritage simple avec chaînage de __index » est-elle gratuite ?

Oui — le texte complet de « Héritage simple avec chaînage de __index » 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 « Héritage simple avec chaînage de __index » ?

Définissez une classe parente comme __index d’une métatable afin d’hériter de ses méthodes. 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 1 sur 4.

Combien de temps prend la leçon « Héritage simple avec chaînage de __index » ?

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

Héritage simple avec chaînage de __index
Appeler les méthodes parentes avec super
Modèles de mixins
Redéfinition et polymorphisme

← Retour à Lua Academy