Ruby tukee yhden perinnön mallia (<) — luokka perii yhden yliluokan. Kun kutsut metodia, Ruby hakee hyvin määritellyn metodien hakupolun (esi-isien ketju, mukaan lukien sekoitetut moduulit) löytääkseen sen. Tämän polun ymmärtäminen selittää, kuinka perintö ja sekoitukset ratkaisevat metodeja.
() = = name
=
<
.new().speak
.new().fetch
Aliluokka (Dog < Animal) perii yliluokan metodit ja instanssimuuttujat ja voi korvata metodeja. super kutsuu vanhemman versiota.
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
Kun kutsut metodia, Ruby kulkee esi-isien ketjua pitkin (Class.ancestors): ensin luokan itse, sitten sen sisällytetyt moduulit (sekoitukset — viimeksi sisällytetyt ensin), sitten yliluokka ja sen moduulit, aina BasicObject:iin asti. Ensimmäinen osuma voittaa. Tämä yksittäinen polku selittää, kuinka perintö JA sekoitukset ratkaistaan yhdessä.
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
Perinnön ja metodien hakupolun ymmärtäminen on tärkeä Ruby-tieto sekä luokkahierarkioiden suunnitteluun että — erityisesti — sen ymmärtämiseen, kuinka Ruby ratkaisee metodeja, kun perintö ja sekoitukset yhdistyvät.
Rubyn yhden perinnön malli (<) tarjoaa koodin uudelleenkäyttöä "on-a"-suhteiden kautta, ja super kutsuu vanhemman toteutuksia.
Mutta erityisempi ja tärkeämpi käsite on metodien hakupolku (esi-isien ketju): kun metodia kutsutaan, Ruby hakee hyvin määritellyssä järjestyksessä — ensin luokan itse, sen sisällytetyt moduulit (sekoitukset, viimeksi sisällytetyt ensin), sitten yliluokka ja sen moduulit, aina BasicObject:iin asti — ja ensimmäinen osuma voittaa.
Tämän yksittäisen, yhtenäisen hakupolun ymmärtäminen on kriittistä, koska se selittää, kuinka perintö ja sekoitukset ratkaistaan yhdessä (moduulit lisätään ketjuun, niiden metodit menevät yliluokan edelle), mikä selventää muuten hämmentävää käyttäytymistä siitä, mikä metodi todellakin kutsutaan, kun sinulla on sekä perintö että useita sekoituksia.
Tämä on erityisen tärkeää Rubyssa ottaen huomioon, kuinka paljon se käyttää sekoituksia — tieto siitä, että Class.ancestors näyttää tarkan hakujärjestyksen, ja kuinka moduulit sopivat siihen, antaa sinulle kyvyn päätellä ja korjata metodien ratkaisua.
Perinnön, super:n ja erityisesti metodien hakupolun ymmärtäminen (kuinka esi-isien ketju ratkaisee metodeja luokkien ja sekoitettujen moduulien yli) on tärkeää, usein relevanttia tietoa Rubyn luokkajärjestelmän kanssa työskentelemiseen, "mikä metodi kutsutaan?" -kysymysten debuggaamiseen ja luokka/moduuli-hierarkioiden suunnitteluun — ja se on yleinen haastattelun aihe, joka heijastaa syvempää ymmärrystä Rubyn objektimalista ja sen erottavasta yhdistelmästä yhden perinnön kanssa tehokkaisiin sekoituksiin.