Ruby ఏకశ్రేణీ వారసత్వం (<) సపోర్ట్ చేస్తుంది — ఒక క్లాస్ ఒక సూపర్క్లాస్ నుండి వారసత్వం పొందుతుంది. మీరు ఒక పద్ధతిని కాల్ చేసినప్పుడు, 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
ఒక సబ్క్లాస్ (Dog < Animal) సూపర్క్లాస్ యొక్క పద్ధతులు మరియు ఉదాహరణ చరరాశులను వారసత్వం పొందుతుంది, మరియు పద్ధతులను భరించవచ్చు. super పేరెంట్ యొక్క సంస్కరణను కాల్ చేస్తుంది.
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 పూర్వీకుల చేయిన (Class.ancestors) ని నడిచేస్తుంది: క్లాస్ కూడా, అప్పుడు దాని చేర్చిన మాడ్యూల్లు (మిక్సిన్లు — చాలా ఇటీవల చేర్చిన మొదటిది), అప్పుడు సూపర్క్లాస్ మరియు దాని మాడ్యూల్లు, BasicObject వరకు. మొదటి సరిపోలిక గెలుస్తుంది. ఈ ఏకశ్రేణీ పాత్ వారసత్వం మరియు మిక్సిన్లు రెండూ ఎలా సమాధానం చేస్తాయో వివరిస్తుంది.
మిక్సిన్లు లుకప్ పాత్లో సరిపోతాయి
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 జ్ఞానం కోసం ముఖ్యమైనది క్లాస్ క్రమానికి ఆకారం ఇవ్వడం కోసం మరియు — ప్రత్యేకించి — Ruby వారసత్వం మరియు మిక్సిన్ల సమ్మేళన ఎలా పద్ధతులను సమాధానం చేస్తుందో అర్థం చేసుకోవడం కోసం.
Ruby యొక్క ఏకశ్రేణీ వారసత్వం (<) "is-a" సంబంధాల ద్వారా కోడ్ పునర్వినియోగం కలిగిస్తుంది, పేరెంట్ అమలుకరణలను కాల్ చేయడానికి super ఉన్నది.
కానీ మరింత విలక్షణమైన మరియు ముఖ్యమైన భావన పద్ధతి లుకప్ పాత్ (పూర్వీకుల చేయిన): ఒక పద్ధతిని కాల్ చేసినప్పుడు, Ruby ఒక సూచిబద్ధ క్రమంలో అన్వేషిస్తుంది — క్లాస్ కూడా, దాని చేర్చిన మాడ్యూల్లు (మిక్సిన్లు, చాలా ఇటీవల చేర్చిన మొదటిది), అప్పుడు సూపర్క్లాస్ మరియు దాని మాడ్యూల్లు, BasicObject వరకు — మరియు మొదటి సరిపోలిక గెలుస్తుంది.
ఈ ఏకశ్రేణీ, ఏకీకృత లుకప్ పాత్ను అర్థం చేసుకోవడం చాలా ముఖ్యమైనది ఎందుకంటే ఇది వారసత్వం మరియు మిక్సిన్లు ఎలా సమ్మిళితంగా సమాధానం చేస్తాయో వివరిస్తుంది (మాడ్యూల్లు చేయిన చేర్చబడతాయి, వాటి పద్ధతులు సూపర్క్లాస్ యొక్క వాటిపై ఆధిక్యతను కలిగి ఉంటాయి), ఇది లేకపోతే గందరగోళంగా ఉన్న ప్రవర్తన గురించి స్పష్టం చేస్తుంది మీకు వారసత్వం మరియు బహుళ మిక్సిన్లు రెండూ ఉన్నప్పుడు ఏ పద్ధతి వాస్తవానికి కాల్ చేయబడుతుంది.
ఇది Ruby లో ముఖ్యంగా ముఖ్యమైనది ఎందుకంటే ఇది మిక్సిన్లను చాలా ఎక్కువ ఉపయోగిస్తుంది — Class.ancestors సరిగ్గా లుకప్ క్రమాన్ని చూపుతుందని, మరియు మాడ్యూల్లు దానిలోకి ఎలా సరిపోతాయో తెలుసుకోవడం అనేది మీకు పద్ధతి నిర్ణయం గురించి తర్కించటానికి మరియు డీబగ్ చేయటానికి అనుమతిస్తుంది.
వారసత్వం, super, మరియు ప్రత్యేకించి పద్ధతి లుకప్ పాత్ (పూర్వీకుల చేయిన ఎలా క్లాస్లు మరియు మిక్సిన్చేయిన మాడ్యూల్లలో పద్ధతులను సమాధానం చేస్తుంది) అర్థం చేసుకోవడం ముఖ్యమైనది, తరచుగా సంబంధితమైన జ్ఞానం Ruby యొక్క క్లాస్ సిస్టమ్తో పనిచేయటానికి, "ఏ పద్ధతి పిలువబడుతోంది?" ప్రశ్నలను డీబగ్ చేయటానికి, మరియు క్లాస్/మాడ్యూల్ సంస్థను నిర్ణయించటానికి — మరియు ఇది అందరి యొక్క సాధారణ ఇంటర్వ్యూ విషయం Ruby యొక్క ఆబ్జెక్ట్ మోడల్ కు లోతైన అవగతను ప్రతిబింబిస్తుంది మరియు దాని విలక్షణమైన సంయోజనం ఏకశ్రేణీ వారసత్వం శక్తిశాలీ మిక్సిన్ల ఉపయోగం.