వారసత్వం ఒక తరగతి (ఉప-తరగతి లేదా సంతానం) మరొక తరగతి (సూపర్-తరగతి లేదా తల్లిదండ్రు) యొక్క ఫీల్డ్లు మరియు పద్ధతులను పునరుపయోగించుకోవచ్చు మరియు విస్తరించుకోవచ్చు. ఇది is-a సంబంధాన్ని రూపొందిస్తుంది: Dog is Animal.
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
return f"{self.name} is eating"
class Dog(Animal): # Dog inherits everything from Animal
def bark(self): # ...and adds new behavior
return "Woof!"
d = Dog("Rex")
print(d.eat()) # "Rex is eating" → inherited, not rewritten
print(d.bark()) # "Woof!" → Dog-specific
Dog __init__ మరియు eat ఉచితంగా పొందింది మరియు bark జోడించింది. ఉప-తరగతి వారసత్వం పద్ధతులను తిరిగి వ్రాయవచ్చు ప్రవర్తనను మార్చడానికి.
| ప్రయోజనం | ఝుందుఖ్పటి |
|---|---|
| భాగస్వామ్య కోడ్ పునరుపయోగం | తల్లిదండ్రు తరగతికి గట్టి సంబంధం |
| నిజమైన క్రమానికి రూపం ఇవ్వండి | దుర్బల ఆధార తరగతి — తల్లిదండ్రు పరిణామాలు బిల్లలను విచ్ఛిన్నం చేస్తాయి |
| సాధారణ రకం ద్వారా బహుళత్వం | లోతైన వృక్షాలు అనుసరించడం కష్టమవుతుంది |
సాధారణ మార్గదర్శకం: సంబంధం "has-a" అయినప్పుడు "is-a" కాకపోతే, వారసత్వంపై సమ్మతిని ఎంచుకోండి.
వారసత్వం అత్యంత దుర్వినియోగ OOP లక్షణం: కేవలం కోడ్ భాగస్వామ్యానికి దానిని ఉపయోగించడానికి ఇది ప్రలోభనకరమైనది, ఇది సంబంధం లేని తరగతులను కలుపుతుంది.
సరిగ్గా ఉపయోగించినప్పుడు — నిజమైన is-a సంబంధాల కోసం మాత్రమే — ఇది మీకు పునరుపయోగం మరియు బహుళత్వం ఇస్తుంది, అనేక ఉప-రకాలను వాటి సాధారణ తల్లిదండ్రు ద్వారా ఏకరూపంగా నిర్వహించడానికి అనుమతిస్తుంది.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం