inheritance और method lookup कैसे काम करते हैं?

Question

Accepted Answer

Ruby **single inheritance** (`<`) का समर्थन करता है — एक class एक superclass से inherit करता है। जब आप एक method call करते हैं, तो Ruby एक अच्छी तरह से परिभाषित **method lookup path** (ancestor chain, mixed-in modules सहित) में खोजता है। इस path को समझना यह स्पष्ट करता है कि inheritance और mixins methods को कैसे resolve करते हैं। ## 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 ``` एक subclass (`Dog < Animal`) superclass के methods और instance variables को inherit करता है, और methods को override कर सकता है। `super` parent के version को call करता है। ## super — call the parent method ```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 ``` ## The 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 ``` जब आप एक method call करते हैं, तो Ruby **ancestor chain** (`Class.ancestors`) पर चलता है: स्वयं class, फिर इसके included **modules** (mixins — सबसे हाल में included पहले), फिर superclass और इसके modules, `BasicObject` तक। पहला match जीतता है। यह एकल path यह स्पष्ट करता है कि inheritance और mixins एक साथ कैसे resolve होते हैं। ## Mixins fit into the 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 ``` ## यह क्यों महत्वपूर्ण है inheritance और **method lookup path** को समझना class hierarchies को design करने और — विशेष रूप से — यह समझने के लिए कि Ruby inheritance और mixins के संयोजन पर methods को कैसे resolve करता है, दोनों के लिए महत्वपूर्ण Ruby ज्ञान है। Ruby का **single inheritance** (`<`) "is-a" relationships के माध्यम से code reuse प्रदान करता है, parent implementations को call करने के लिए `super` के साथ। लेकिन अधिक विशिष्ट और महत्वपूर्ण अवधारणा है **method lookup path** (ancestor chain): जब एक method call होता है, तो Ruby एक अच्छी तरह से परिभाषित क्रम में खोजता है — स्वयं class, इसके included **modules** (mixins, सबसे-हाल-में-included पहले), फिर superclass और इसके modules, `BasicObject` तक — और पहला match जीतता है। इस एकल, एकीकृत lookup path को समझना महत्वपूर्ण है क्योंकि यह स्पष्ट करता है कि **inheritance और mixins एक साथ कैसे resolve होते हैं** (modules chain में डाले जाते हैं, उनके methods superclass के methods पर प्राथमिकता लेते हैं), जो अन्यथा-भ्रमित करने वाले behavior को स्पष्ट करता है कि जब आपके पास inheritance और कई mixins दोनों हों तो वास्तव में कौन सा method call होता है। यह Ruby में विशेष रूप से महत्वपूर्ण है क्योंकि यह कितनी भारी मात्रा में mixins का उपयोग करता है — यह जानना कि `Class.ancestors` सटीक lookup क्रम दिखाता है, और modules इसमें कैसे फिट होते हैं, आपको method resolution के बारे में तर्क करने और debug करने देता है। inheritance, `super`, और विशेष रूप से method lookup path (कैसे ancestor chain classes और mixed-in modules में methods को resolve करता है) को समझना Ruby की class system के साथ काम करने, "कौन सा method call हो रहा है?" प्रश्नों को debug करने, और class/module hierarchies को design करने के लिए महत्वपूर्ण, बार-बार प्रासंगिक ज्ञान है — और यह एक आम interview विषय है जो Ruby के object model और single inheritance के शक्तिशाली mixins के साथ इसके विशिष्ट संयोजन की गहरी समझ को दर्शाता है।