Ruby सिंगल इनहेरिटन्स (<) सपोर्ट करते — एक क्लास एका सुपरक्लासमधून इनहेरिट करते. जेव्हा तुम्ही एक मेथड कॉल करता, तब Ruby एक सुस्पष्ट मेथड लुकअप पाथ (ancestor chain, mixed-in modules समावेश करून) शोधते. हा पाथ समजल्यास इनहेरिटन्स आणि mixins कसे रिजॉल्व होतात हे समजते.
() = = name
=
<
.new().speak
.new().fetch
एक subclass (Dog < Animal) सुपरक्लासच्या मेथड्स आणि instance variables इनहेरिट करते, आणि मेथड्स ओव्हरराइड करू शकते. super पॅरेंटचा व्हर्जन कॉल करते.
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
जेव्हा तुम्ही एक मेथड कॉल करता, Ruby ancestor chain (Class.ancestors) वर चालतो: क्लास स्वतः, नंतर त्याचे included modules (mixins — सर्वात अलीकडे included प्रथम), नंतर सुपरक्लास आणि त्याचे modules, BasicObject पर्यंत. पहिली match जिंकते. हा सिंगल पाथ समजावते की कसे इनहेरिटन्स आणि mixins एकत्रितपणे रिजॉल्व होतात.
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
इनहेरिटन्स आणि मेथड लुकअप पाथ समजणे हे Ruby चे महत्वाचे ज्ञान आहे, दोन्ही क्लास हायरार्किज डिজाईन करण्यासाठी आणि — विशेषतः — जेव्हा इनहेरिटन्स आणि mixins एकत्रित होतात तेव्हा Ruby कसे मेथड्स रिजॉल्व करते हे समजण्यासाठी.
Ruby चे सिंगल इनहेरिटन्स (<) "is-a" संबंधांद्वारे कोड रियूज प्रदान करते, super सह पॅरेंट इम्प्लिमेंटेशन्स कॉल करण्यासाठी.
पण अधिक विशिष्ट आणि महत्वाचे संकल्पना आहे मेथड लुकअप पाथ (the ancestor chain): जेव्हा एक मेथड कॉल केला जातो, Ruby एक सुस्पष्ट क्रमात शोधते — क्लास स्वतः, त्याचे included modules (mixins, most-recently-included प्रथम), नंतर सुपरक्लास आणि त्याचे modules, BasicObject पर्यंत — आणि पहिली match जिंकते.
हा सिंगल, एकीकृत लुकअप पाथ समजणे महत्वाचे आहे कारण ते समजावते की कसे इनहेरिटन्स आणि mixins एकत्रितपणे रिजॉल्व होतात (modules चेनमध्ये घुसवले जातात, त्यांचे मेथड्स सुपरक्लासच्या आधीपूर्वी), जे अन्यथा गोंधळलेल्या वर्तनास स्पष्ट करते जेव्हा तुमच्याकडे इनहेरिटन्स आणि अनेक mixins दोन्ही असतात तेव्हा कोणता मेथड खरोखर कॉल होतो.
हे Ruby मध्ये विशेषतः महत्वाचे आहे कारण ते mixins हेवीली वापरते — जेव्हा Class.ancestors अचूक लुकअप क्रम दर्शविते, आणि modules त्यात कसे बसतात हे जाणून घेतल्यास, तुम्ही मेथड रेजोल्यूशनबद्दल विचार करू शकता आणि डीबग करू शकता.
इनहेरिटन्स, super, आणि विशेषतः मेथड लुकअप पाथ (कसे ancestor chain क्लासेस आणि mixed-in modules भोवती मेथड्स रिजॉल्व करते) समजणे हे महत्वाचे, वारंवार-प्रासंगिक ज्ञान आहे Ruby च्या क्लास सिस्टमसह कामासाठी, "कोणता मेथड कॉल केला जात आहे?" प्रश्नांची डीबगिंग करण्यासाठी, आणि क्लास/मॉड्यूल हायरार्किज डिजाईन करण्यासाठी — आणि हे एक सामान्य इंटरव्यू विषय आहे जो Ruby च्या ऑब्जेक्ट मॉडेलचे गहरे समजून आणि त्याचे विशिष्ट सिंगल इनहेरिटन्स आणि शक्तिशाली mixins यांचा संयोजन प्रतिबिंबित करते.