Ruby supporta l'ereditarietà singola (<) — una classe eredita da una sola superclasse. Quando chiami un metodo, Ruby cerca in un percorso di ricerca dei metodi ben definito (la catena degli antenati, inclusi i moduli mixati) per trovarlo. Comprendere questo percorso spiega come l'ereditarietà e i mixin risolvono i metodi.
() = = name
=
<
.new().speak
.new().fetch
Una sottoclasse (Dog < Animal) eredita i metodi e le variabili di istanza della superclasse e può sovrascrivere i metodi. super chiama la versione del genitore.
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
Quando chiami un metodo, Ruby percorre la catena degli antenati (Class.ancestors): la classe stessa, quindi i suoi moduli inclusi (mixin — inclusi più di recente per primi), quindi la superclasse e i suoi moduli, fino a BasicObject. La prima corrispondenza vince. Questo percorso singolo spiega come l'ereditarietà E i mixin si risolvono insieme.
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
Comprendere l'ereditarietà e il percorso di ricerca dei metodi è una conoscenza di Ruby importante sia per progettare gerarchie di classi sia — soprattutto — per capire come Ruby risolve i metodi quando l'ereditarietà e i mixin si combinano.
L'ereditarietà singola di Ruby (<) fornisce riutilizzo del codice tramite relazioni "is-a", con super per chiamare le implementazioni dei genitori.
Ma il concetto più distintivo e importante è il percorso di ricerca dei metodi (la catena degli antenati): quando un metodo viene chiamato, Ruby ricerca in un ordine ben definito — la classe stessa, i suoi moduli inclusi (mixin, inclusi più di recente per primi), quindi la superclasse e i suoi moduli, fino a BasicObject — e la prima corrispondenza vince.
Comprendere questo percorso di ricerca singolo e unificato è cruciale perché spiega come l'ereditarietà e i mixin si risolvono insieme (i moduli vengono inseriti nella catena, i loro metodi hanno la precedenza su quelli della superclasse), il che chiarisce il comportamento altrimenti confuso su quale metodo effettivamente viene chiamato quando hai sia l'ereditarietà sia più mixin.
Questo è particolarmente importante in Ruby dato quanto ampiamente usa i mixin — sapere che Class.ancestors mostra l'ordine esatto di ricerca e come i moduli si inseriscono in esso ti permette di ragionare su e debuggare la risoluzione dei metodi.
Comprendere l'ereditarietà, super e soprattutto il percorso di ricerca dei metodi (come la catena degli antenati risolve i metodi attraverso le classi e i moduli mixati) è una conoscenza importante e frequentemente rilevante per lavorare con il sistema di classi di Ruby, debuggare le domande "quale metodo viene chiamato?", e progettare gerarchie di classi/moduli — ed è un argomento comune nei colloqui che riflette una comprensione più profonda del modello di oggetti di Ruby e la sua combinazione distintiva di ereditarietà singola con potenti mixin.