Ruby suportă moștenire simplă (<) — o clasă moștenește de la o singură superclasă. Când apelezi o metodă, Ruby caută într-o cale de căutare a metodelor bine definită (lanțul de ancestors, inclusiv modulele mixate) pentru a o găsi. Înțelegerea acestei căi explică modul în care moștenirea și mixins rezolvă metodele.
() = = name
=
<
.new().speak
.new().fetch
O subclasă (Dog < Animal) moștenește metodele și variabilele de instanță ale superclaseicăi și poate suprascrie metodele. super apelează versiunea părintelui.
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
Când apelezi o metodă, Ruby parcurge lanțul de ancestors (Class.ancestors): clasa în sine, apoi modulele sale incluse (mixins — cele mai recent incluse primele), apoi superclasa și modulele acesteia, până la BasicObject. Prima potrivire câștigă. Această cale unică explică modul în care atât moștenirea cât și mixins se rezolvă împreună.
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
Înțelegerea moștenirii și a caii de căutare a metodelor este o cunoaștere importantă în Ruby atât pentru proiectarea ierarhiilor de clase cât și — în special — pentru înțelegerea modului în care Ruby rezolvă metodele când moștenirea și mixins se combină.
Moștenirea simplă a Ruby (<) oferă reutilizare de cod prin relații de tip "este-un", cu super pentru a apela implementări parentale.
Dar conceptul mai distinctive și mai important este calea de căutare a metodelor (lanțul de ancestors): când o metodă este apelată, Ruby caută într-o ordine bine definită — clasa în sine, modulele sale incluse (mixins, cele mai recent incluse primele), apoi superclasa și modulele acesteia, până la BasicObject — și prima potrivire câștigă.
Înțelegerea acestei căi de căutare unice și unificate este crucială deoarece explică modul în care moștenirea și mixins se rezolvă împreună (modulele sunt inserate în lanț, metodele lor având prioritate față de cea a superclaseicăi), ceea ce clarifică comportament confuz în caz contrar cu privire la care metodă este de fapt apelată când ai atât moștenire cât și multiple mixins.
Acest lucru este deosebit de important în Ruby având în vedere cât de mult folosește mixins — știind că Class.ancestors arată ordinea exactă de căutare și cum se încadrează modulele în ea, îți permite să raționezi și să depanezi rezolvarea metodelor.
Înțelegerea moștenirii, super, și în special a caii de căutare a metodelor (cum lanțul de ancestors rezolvă metodele în clase și module mixate) este o cunoaștere importantă și frecvent relevantă pentru lucrul cu sistemul de clase al Ruby, depanarea întrebărilor "care metodă este apelată?", și proiectarea ierarhiilor de clase/module — și este un subiect comun în interviuri care reflectă o înțelegere mai profundă a modelului de obiecte al Ruby și a combinației sale distinctive de moștenire simplă cu mixins puternice.