Ruby ondersteunt enkele overerving (<) — een klasse erft van één superklasse. Wanneer je een methode aanroept, doorzoekt Ruby een goed gedefinieerd methode-zoekpad (de ancestor chain, inclusief gemengde modules) om het te vinden. Het begrijpen van dit pad verklaart hoe overerving en mixins methoden oplossen.
() = = name
=
<
.new().speak
.new().fetch
Een subklasse (Dog < Animal) erft de methoden en instantievariabelen van de superklasse en kan methoden overschrijven. super roept de versie van de ouder aan.
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
Wanneer je een methode aanroept, loopt Ruby door de ancestor chain (Class.ancestors): de klasse zelf, dan de opgenomen modules (mixins — meest recent opgenomen eerst), dan de superklasse en zijn modules, tot BasicObject. De eerste overeenkomst wint. Dit enkele pad verklaart hoe overerving EN mixins samen methoden oplossen.
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
Het begrijpen van overerving en het methode-zoekpad is belangrijke Ruby-kennis voor zowel het ontwerpen van klassiëke hiërarchieën als — vooral — het begrijpen hoe Ruby methoden oplost wanneer overerving en mixins samen voorkomen.
Ruby's enkele overerving (<) biedt code-hergebruik via "is-a"-relaties, met super om ouderimplementaties aan te roepen.
Maar het meer karakteristieke en belangrijke concept is het methode-zoekpad (de ancestor chain): wanneer een methode wordt aangeroepen, doorzoekt Ruby in een goed gedefinieerde volgorde — de klasse zelf, de opgenomen modules (mixins, meest recent opgenomen eerst), dan de superklasse en zijn modules, tot BasicObject — en de eerste overeenkomst wint.
Het begrijpen van dit enkele, uniforme zoekpad is cruciaal omdat het verklaart hoe overerving en mixins samen worden opgelost (modules worden in de chain ingevoegd, hun methoden hebben voorrang op die van de superklasse), wat anders verwarrend gedrag verduidelijkt over welke methode daadwerkelijk wordt aangeroepen wanneer je zowel overerving als meerdere mixins hebt.
Dit is vooral belangrijk in Ruby vanwege het intensieve gebruik van mixins — weten dat Class.ancestors de exacte zoekorde toont en hoe modules erin passen, stelt je in staat methode-resolutie te redeneren en te debuggen.
Het begrijpen van overerving, super en vooral het methode-zoekpad (hoe de ancestor chain methoden over klassen en gemengde modules oplost) is belangrijke, regelmatig relevante kennis voor het werken met Ruby's klassensysteem, het debuggen van "welke methode wordt aangeroepen?"-vragen en het ontwerpen van klasse-/module-hiërarchieën — en het is een veelvoorkomend interviewonderwerp dat dieper begrip van Ruby's objectmodel en de karakteristieke combinatie van enkele overerving met krachtige mixins weerspiegelt.