Ruby ndhukung single inheritance (<) — sawijining kelas ngarepno saka sawise superclass. Nalika sampeyan nggawe method, Ruby nggoleki method lookup path sing wus ditetepake (ancestor chain, kalebu modules sing dicampur) kanggo nemokake. Mangerti path iki nerangake carane inheritance lan mixins ngrampungake methods.
() = = name
=
<
.new().speak
.new().fetch
Subclass (Dog < Animal) ngarepake methods lan instance variables saka superclass, lan bisa ngatasi methods. super nggawe parent 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
Nalika sampeyan nggawe method, Ruby mlaku-mlaku ancestor chain (Class.ancestors): kelas dhéwé, banjur modules sing kalebu (mixins — sing paling akeh dilebokake dhisik), banjur superclass lan modules-ne, nganti BasicObject. Sing cocog pisanan sing menang. Path tunggal iki nerangake carane inheritance LAN mixins ngrampungake.
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
Mangerti inheritance lan method lookup path minangka pangetahuan Ruby sing penting kanggo ngrancang class hierarchies lan — luwih-luwih — mangerti carane Ruby ngrampungake methods nalika inheritance lan mixins padha.
Ruby single inheritance (<) nyedhiyakake code reuse liwat relasi "is-a", karo super kanggo nggawe parent implementations.
Nanging konsep sing luwih khas lan penting yaiku method lookup path (ancestor chain): nalika method dipanggilaké, Ruby nggoleki ing urutan sing wus ditetepake — kelas dhéwé, modules sing kalebu (mixins, sing paling akeh dilebokake dhisik), banjur superclass lan modules-ne, nganti BasicObject — lan sing cocog pisanan sing menang.
Mangerti path lookup tunggal sing gabung minangka penting banget amarga nerangake carane inheritance lan mixins ngrampungake bebarengan (modules dilebokake ing chain, methods-ne nduwur priority saka superclass), sing nerangake perilaku sing nggumunake babagan cara method sing bener-bener dipanggilaké nalika sampeyan duwe inheritance lan mixins pirang-pirang.
Iki luwih-luwih penting ing Ruby amarga cara padheneng nggunakake mixins — mangerti yen Class.ancestors nunjukake urutan lookup sing bener, lan cara modules cocog menyang iku, ngidini sampeyan kanggo mikirake lan debug method resolution.
Mangerti inheritance, super, lan luwih-luwih method lookup path (carane ancestor chain ngrampungake methods ing kelas lan modules sing dicampur) minangka pangetahuan sing penting, sring relevan kanggo gawe Ruby class system, ngrampungake "cara method sing dipanggilaké?" pitakonan, lan ngrancang class/module hierarchies — lan iki topik umum interview sing nerangake mangerti luwih jero babagan Ruby object model lan kombinasi khas-ne antara single inheritance karo mixins sing kuat.