Ruby supporte l'héritage simple (<) — une classe hérite d'une seule superclasse. Quand vous appelez une méthode, Ruby parcourt un chemin de recherche de méthode bien défini (la chaîne d'ancêtres, incluant les modules mixés) pour la trouver. Comprendre ce chemin explique comment l'héritage et les mixins résolvent les méthodes.
() = = name
=
<
.new().speak
.new().fetch
Une sous-classe (Dog < Animal) hérite des méthodes et variables d'instance de la superclasse, et peut surcharger les méthodes. super appelle la version du parent.
class Dog < Animal
def initialize(name, breed)
super(name) # call Animal#initialize
@breed = breed
end
def speak
super + " (woof)" # super (no parens) passes the same args; here calls Animal#speak
end
end
# Ruby searches for a method in this ORDER (the ancestors chain):
Dog.ancestors
# => [Dog, <included modules>, Animal, <Animal's modules>, Object, Kernel, BasicObject]
# lookup: the class itself → its included MODULES (last included first) →
# the superclass → ITS modules → ... up to BasicObject
Quand vous appelez une méthode, Ruby parcourt la chaîne d'ancêtres (Class.ancestors) : la classe elle-même, puis ses modules inclus (mixins — les plus récemment inclus d'abord), puis la superclasse et ses modules, jusqu'à BasicObject. Le premier résultat gagne. Ce chemin unique explique comment l'héritage ET les mixins se résolvent ensemble.
module Swimmer
def move = "swimming"
end
class Fish < Animal
include Swimmer # Swimmer is inserted into the lookup path (before Animal)
end
# Fish.ancestors → [Fish, Swimmer, Animal, ...] — a module's methods come before the superclass's
Comprendre l'héritage et le chemin de recherche de méthode est une connaissance Ruby importante pour concevoir des hiérarchies de classes et — surtout — comprendre comment Ruby résout les méthodes quand l'héritage et les mixins se combinent.
L'héritage simple de Ruby (<) fournit la réutilisation de code via les relations "est-un", avec super pour appeler les implémentations du parent.
Mais le concept le plus distinctif et important est le chemin de recherche de méthode (la chaîne d'ancêtres) : quand une méthode est appelée, Ruby cherche dans un ordre bien défini — la classe elle-même, ses modules inclus (mixins, les plus récemment inclus d'abord), puis la superclasse et ses modules, jusqu'à BasicObject — et le premier résultat gagne.
Comprendre ce chemin unique et unifié est crucial car il explique comment l'héritage et les mixins se résolvent ensemble (les modules sont insérés dans la chaîne, leurs méthodes ayant priorité sur celles de la superclasse), ce qui clarifie un comportement autrement déroutant concernant la méthode qui est réellement appelée quand vous avez à la fois de l'héritage et plusieurs mixins.
C'est particulièrement important en Ruby étant donné son utilisation intensive des mixins — savoir que Class.ancestors montre l'ordre exact de recherche, et comment les modules s'y intègrent, vous permet de raisonner sur et déboguer la résolution de méthode.
Comprendre l'héritage, super, et surtout le chemin de recherche de méthode (comment la chaîne d'ancêtres résout les méthodes à travers les classes et les modules mixés) est une connaissance importante et pertinente pour travailler avec le système de classes de Ruby, déboguer les questions "quelle méthode est appelée ?", et concevoir des hiérarchies de classes/modules — et c'est un sujet d'interview courant qui reflète une compréhension plus profonde du modèle d'objet de Ruby et sa combinaison distinctive de l'héritage simple avec des mixins puissants.