Bagaimana cara kerja inheritance dan method lookup?

Question

Accepted Answer

Ruby mendukung **single inheritance** (`<`) — sebuah class mewarisi dari satu superclass. Ketika Anda memanggil sebuah method, Ruby mencari melalui **method lookup path** yang terdefinisi dengan baik (ancestor chain, termasuk module yang dimixin) untuk menemukannya. Memahami path ini menjelaskan bagaimana inheritance dan mixins menyelesaikan method. ## Single inheritance ```ruby class Animal def initialize(name) = @name = name def speak = "some sound" end class Dog < Animal # Dog inherits from Animal (single inheritance) def speak # override "Woof" end def fetch "#{@name} fetches" # @name inherited from Animal end end Dog.new("Rex").speak # "Woof" (overridden) Dog.new("Rex").fetch # uses inherited @name ``` Sebuah subclass (`Dog < Animal`) mewarisi method dan instance variable dari superclass, dan dapat mengoverride method. `super` memanggil versi parent. ## super — panggil method parent ```ruby 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 ``` ## Method lookup path (ancestor chain) ```ruby # Ruby searches for a method in this ORDER (the ancestors chain): Dog.ancestors # => [Dog, , Animal, , Object, Kernel, BasicObject] # lookup: the class itself → its included MODULES (last included first) → # the superclass → ITS modules → ... up to BasicObject ``` Ketika Anda memanggil sebuah method, Ruby berjalan melalui **ancestor chain** (`Class.ancestors`): class itu sendiri, kemudian **module** yang diinclude (mixins — yang paling baru diinclude terlebih dahulu), kemudian superclass dan module-nya, hingga `BasicObject`. Kecocokan pertama menang. Path tunggal ini menjelaskan bagaimana inheritance DAN mixins menyelesaikan method bersama-sama. ## Mixins pas ke dalam lookup path ```ruby 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 ``` ## Mengapa ini penting Memahami inheritance dan **method lookup path** adalah pengetahuan Ruby yang penting baik untuk merancang class hierarchies dan — terutama — memahami bagaimana Ruby menyelesaikan method ketika inheritance dan mixins bergabung. **Single inheritance** Ruby (`<`) menyediakan code reuse melalui relasi "is-a", dengan `super` untuk memanggil implementasi parent. Tapi konsep yang lebih khas dan penting adalah **method lookup path** (ancestor chain): ketika sebuah method dipanggil, Ruby mencari dalam urutan yang terdefinisi dengan baik — class itu sendiri, **module** yang diinclude (mixins, yang paling baru diinclude terlebih dahulu), kemudian superclass dan module-nya, hingga `BasicObject` — dan kecocokan pertama menang. Memahami path lookup tunggal dan terpadu ini sangat penting karena menjelaskan bagaimana **inheritance dan mixins menyelesaikan method bersama-sama** (module dimasukkan ke dalam chain, method mereka mendahului superclass), yang menjelaskan perilaku yang otherwise-confusing tentang method mana yang sebenarnya dipanggil ketika Anda memiliki inheritance dan multiple mixins. Ini sangat penting di Ruby mengingat betapa banyak penggunaan mixins — mengetahui bahwa `Class.ancestors` menunjukkan urutan lookup yang tepat, dan bagaimana module pas ke dalamnya, memungkinkan Anda untuk menyelamatkan dan men-debug method resolution. Memahami inheritance, `super`, dan khususnya method lookup path (bagaimana ancestor chain menyelesaikan method melintasi class dan module yang dimixin) adalah pengetahuan penting dan sering-relevan untuk bekerja dengan class system Ruby, men-debug pertanyaan "method mana yang dipanggil?", dan merancang class/module hierarchies — dan ini adalah topik interview yang umum yang mencerminkan pemahaman lebih dalam tentang object model Ruby dan kombinasi khasnya dari single inheritance dengan powerful mixins.