Ruby understøtter enkelt arv (<) — en klasse arver fra én superklasse. Når du kalder en metode, søger Ruby gennem en veldefineret metodeopslags-sti (forfader-kæden, inkluderet blandede moduler) for at finde den. At forstå denne sti forklarer, hvordan arv og mixins løser metoder.
() = = name
=
<
.new().speak
.new().fetch
En underklasse (Dog < Animal) arver superklassens metoder og instansvariable og kan tilsidesætte metoder. super kalder forældrenes version.
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
Når du kalder en metode, går Ruby gennem forfader-kæden (Class.ancestors): selve klassen, derefter dens inkluderede moduler (mixins — senest inkluderede først), derefter superklassen og dens moduler, op til BasicObject. Det første match vinder. Denne enkelte sti forklarer, hvordan arv OG mixins løser sammen.
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
At forstå arv og metodeopslags-stien er vigtig Ruby-viden for både at designe klassehierarkier og — især — at forstå, hvordan Ruby løser metoder, når arv og mixins kombineres.
Rubys enkelt arv (<) giver kodegenbrug via "er-en" relationer, med super til at kalde forældrers implementeringer.
Men det mere særegent og vigtige koncept er metodeopslags-stien (forfader-kæden): når en metode kaldes, søger Ruby i en veldefineret orden — selve klassen, dens inkluderede moduler (mixins, senest-inkluderede først), derefter superklassen og dens moduler, op til BasicObject — og det første match vinder.
At forstå denne enkelte, samlede opslags-sti er afgørende, fordi det forklarer, hvordan arv og mixins løser sammen (moduler indsættes i kæden, deres metoder tager forrang over superklassens), hvilket præciserer ellers forvirrende adfærd om, hvilken metode der faktisk bliver kaldt, når du har både arv og multiple mixins.
Dette er særlig vigtigt i Ruby givet hvor meget det bruger mixins — at vide, at Class.ancestors viser den nøjagtige opslags-orden, og hvordan moduler passer ind i den, lader dig begrunde og fejlfinde metodeopløsning.
At forstå arv, super og især metodeopslags-stien (hvordan forfader-kæden løser metoder på tværs af klasser og blandede moduler) er vigtig, hyppigt relevant viden for at arbejde med Rubys klassesystem, fejlfinde "hvilken metode bliver kaldt?" spørgsmål og designe klasse-/modulhierarkier — og det er et almindeligt interviewemne, der afspejler dybere forståelse af Rubys objektmodel og dens særlige kombination af enkelt arv med kraftfulde mixins.