0Pricing
Lua Academy · Leçon

Héritage à plusieurs niveaux

Prenez en charge des chaînes d’héritage profondes avec une délégation correcte de __index.

Héritage à plusieurs niveaux 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.

Révision de l’héritage simple

L’héritage simple s’obtient en définissant Child.__index = Parent. Pour rechercher une méthode, si elle n’existe pas dans Child, cherchez-la dans Parent via __index.

Étendre la fabrique de classes pour l’héritage

Ajoutez une méthode :extend() à la classe de base afin de créer une sous-classe liée à la classe parente.

function Animal:extend()
  local cls = {}
  cls.__index = cls
  setmetatable(cls, {__index = self})
  cls.super = self
  function cls:new(...)
    local inst = setmetatable({}, cls)
    if inst.init then inst:init(...) end
    return inst
  end
  return cls
end

Créer une sous-classe

Créez Dog comme sous-classe d’Animal, en redéfinissant init et en ajoutant de nouvelles méthodes.

local Dog = Animal:extend()
function Dog:init(name)
  Dog.super.init(self, name, "Woof")
  self.tricks = {}
end
function Dog:learnTrick(trick)
  self.tricks[#self.tricks+1] = trick
end
local d = Dog:new("Rex")
d:learnTrick("sit")
d:speak()  -- Rex says Woof

Chaîne à plusieurs niveaux

Étendez Dog pour créer GuideDog — une chaîne d’héritage à trois niveaux.

local GuideDog = Dog:extend()
function GuideDog:init(name, owner)
  GuideDog.super.init(self, name)
  self.owner = owner
end
function GuideDog:guide()
  print(self.name .. " guides " .. self.owner)
end

Appeler les méthodes de la classe parente

Appelez toujours super via la référence de classe, et non via self, pour éviter une récursion infinie.

function Dog:init(name)
  Dog.super.init(self, name, "Woof")  -- explicit super call
end

Ordre de résolution des méthodes

Lua recherche les méthodes de bas en haut dans les chaînes __index. GuideDog → Dog → Animal → nil. La première méthode trouvée est utilisée.

Redéfinir des méthodes

Définissez une méthode portant le même nom dans la sous-classe pour la redéfinir. Appelez explicitement la classe parente pour les redéfinitions partielles.

function Dog:speak()
  print(self.name .. " barks!")
  Dog.super.speak(self)  -- also call parent speak
end

Limites de profondeur

Les chaînes d’héritage très profondes ralentissent la recherche de méthodes (chaque niveau ajoute une étape __index). Préférez la composition au-delà de 3 ou 4 niveaux.

Vérifier l’appartenance à une classe

Parcourez la chaîne de métatables pour vérifier qu’une instance appartient à une classe.

local function isA(instance, cls)
  local mt = getmetatable(instance)
  while mt do
    if mt == cls then return true end
    mt = getmetatable(mt)
  end
  return false
end
print(isA(d, Dog))     -- true
print(isA(d, Animal))  -- true

Copie profonde avec conservation de la classe

Lors de la copie profonde d’instances, conservez la métatable afin que la copie reste une instance de la classe appropriée.

Quand préférer la composition

Utilisez l’héritage pour les véritables relations « est-un » (Dog est un Animal). Utilisez la composition (tables de composants) pour les relations « a-un » ou pour mélanger des comportements avec souplesse.

Question sur l’héritage

Comment fonctionne l’héritage à plusieurs niveaux dans Lua ?

Récapitulatif : héritage à plusieurs niveaux

Étendez la fabrique de classes avec une méthode :extend() qui chaîne les liens __index. Appelez explicitement la classe parente avec ClassName.super.method(self, ...). Vérifiez l’appartenance en parcourant la chaîne de métatables.

Questions Fréquemment Posées

La leçon « Héritage à plusieurs niveaux » est-elle gratuite ?

Oui — le texte complet de « Héritage à plusieurs niveaux » 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 à plusieurs niveaux » ?

Prenez en charge des chaînes d’héritage profondes avec une délégation correcte de __index. 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 « Héritage à plusieurs niveaux » ?

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. Conception de la classe de base et du constructeur
  2. Héritage à plusieurs niveaux
  3. Composition de mixins et vérification des interfaces
  4. instanceof et introspection des types
← Retour à Lua Academy