విషయ సూచిక
C#లో వారసత్వం ఎలా పని చేస్తుంది
C# లో వారసత్వం అంటే ఏమిటి
వారసత్వాన్ని ఉపయోగించి C#లో, ఒక తరగతి మరొక తరగతి యొక్క లక్షణాలు మరియు పద్ధతులను తీసుకోవచ్చు లేదా వారసత్వంగా పొందవచ్చు. మరో మాటలో చెప్పాలంటే, ఇది ఇప్పటికే ఉన్న తరగతి ఆధారంగా కొత్త తరగతిని సృష్టించడానికి అనుమతిస్తుంది, దీనిని బేస్ క్లాస్ లేదా సూపర్ క్లాస్ అని పిలుస్తారు. బేస్ క్లాస్ యొక్క లక్షణాలను తీసుకున్న తర్వాత ఏర్పడిన తరగతిని అంటారు ఒక ఉత్పన్నమైన తరగతి లేదా ఉపవర్గం.
C#లోని ఈ డెరైవ్డ్ క్లాస్ బేస్ క్లాస్ యొక్క లక్షణాలను తీసుకోవడమే కాకుండా దాని స్వంత ప్రత్యేక లక్షణాలను కూడా జోడించగలదు.
C#లో వారసత్వం ఎలా పని చేస్తుంది
C#లో, పెద్దప్రేగును ఉపయోగించడం ద్వారా వారసత్వం సాధించబడుతుంది (:) చిహ్నం. బేస్ క్లాస్ పేరు పెద్దప్రేగు తర్వాత నిర్వచించబడింది మరియు ఇది ఉత్పన్నమైన తరగతి ద్వారా పేర్కొనబడుతుంది.
బేస్ క్లాస్ నుండి ప్రాపర్టీలను తీసుకునే డెరైవ్డ్ క్లాస్‌ని రూపొందించడానికి క్రింది వాక్యనిర్మాణం ఉంది:
తరగతి ఉత్పన్నమైన తరగతి : బేస్ క్లాస్{
// ఉత్పన్నమైన తరగతి సభ్యులు
}
ఇక్కడ ఈ కోడ్‌లో, ఉత్పన్నమైన తరగతి అనేది ఉత్పన్నమైన తరగతి పేరు, మరియు బేస్ క్లాస్ అనేది బేస్ క్లాస్ పేరు. ది : బేస్‌క్లాస్ నుండి డెరైవ్డ్‌క్లాస్ సంక్రమిస్తోందని గుర్తు సూచిస్తుంది. DerivedClass సభ్యులు బేస్‌క్లాస్ సభ్యులను యాక్సెస్ చేయగలరు, వారు ప్రైవేట్ కానట్లయితే.
C#లో వారసత్వ రకాలు
C# నాలుగు రకాల వారసత్వానికి మద్దతు ఇస్తుంది: సింగిల్, బహుళ-స్థాయి, క్రమానుగత మరియు బహుళ వారసత్వం. ప్రతి రకాన్ని చూద్దాం.
ఒకే వారసత్వం
ఒకే వారసత్వం అనేది వారసత్వం యొక్క అత్యంత సాధారణ రకం, ఇక్కడ ఉత్పన్నమైన తరగతి ఒకే మూల తరగతి యొక్క లక్షణాలను తీసుకుంటుంది లేదా వారసత్వంగా పొందుతుంది.
ఉదాహరణకి, ఇచ్చిన కోడ్ క్లాస్ సోపానక్రమాన్ని వివరిస్తుంది మరియు వారసత్వ భావనలను ప్రదర్శిస్తుంది.
సిస్టమ్ ఉపయోగించి ;సిస్టమ్ ఉపయోగించి ;
తరగతి కారు
{
ప్రజా శూన్యం ప్రారంభించండి ( )
{
కన్సోల్. రైట్ లైన్ ( 'కారు స్టార్ట్' ) ;
}
}
తరగతి టెస్లా : కారు
{
ప్రజా శూన్యం వేగవంతం ( )
{
కన్సోల్. రైట్ లైన్ ( 'టెస్లా వేగవంతం' ) ;
}
}
తరగతి కార్యక్రమం
{
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
టెస్లా మై టెస్లా = కొత్త టెస్లా ( ) ;
myTesla. ప్రారంభించండి ( ) ; // అవుట్‌పుట్: కారు స్టార్ట్ చేయబడింది
myTesla. వేగవంతం ( ) ; // అవుట్‌పుట్: టెస్లా వేగవంతం
}
}
పై కోడ్‌లో, ది కారు తరగతి బేస్ క్లాస్ మరియు అనే పద్ధతిని కలిగి ఉంటుంది ప్రారంభం() , ఇది కేవలం సందేశాన్ని ప్రింట్ చేస్తుంది కారు స్టార్ట్ అయింది కన్సోల్‌కి.
ది టెస్లా తరగతి కార్ క్లాస్ నుండి తీసుకోబడింది మరియు ఇది కార్ క్లాస్ యొక్క అన్ని లక్షణాలను తీసుకుంటుంది. టెస్లా క్లాస్ అనే పద్ధతిని జోడిస్తుంది వేగవంతం() , ఇది సందేశాన్ని ముద్రిస్తుంది టెస్లా వేగవంతం కన్సోల్‌కి.
ది ప్రధాన() ఫంక్షన్ టెస్లా క్లాస్ అని పిలువబడే ఒక ఉదాహరణను నిర్వచిస్తుంది myTesla మరియు దాని స్టార్ట్() మరియు యాక్సిలరేట్() పద్ధతులను పిలుస్తుంది.
బహుళ-స్థాయి వారసత్వం
బహుళ-స్థాయి వారసత్వం అనేది ఒక ఉత్పన్నమైన తరగతి మరొక ఉత్పన్న తరగతి నుండి వారసత్వంగా పొందుతుంది, ఇది మూల తరగతి నుండి వారసత్వంగా వస్తుంది.
ఉదాహరణకి, కింది C# కోడ్ వారసత్వం మరియు క్లాస్ సోపానక్రమంలో ఓవర్‌రైడింగ్ పద్ధతిని ప్రదర్శిస్తుంది.
సిస్టమ్ ఉపయోగించి ;తరగతి జంతువు
{
ప్రజా శూన్యం తినండి ( )
{
కన్సోల్. రైట్ లైన్ ( 'జంతువులు తినడం' ) ;
}
}
తరగతి క్షీరదం : జంతువు
{
ప్రజా శూన్యం పరుగు ( )
{
కన్సోల్. రైట్ లైన్ ( 'క్షీరదం పరుగు' ) ;
}
}
తరగతి కుక్క : క్షీరదం
{
ప్రజా శూన్యం బెరడు ( )
{
కన్సోల్. రైట్ లైన్ ( 'కుక్క మొరిగేది' ) ;
}
}
తరగతి కార్యక్రమం
{
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
డాగ్ మై డాగ్ = కొత్త కుక్క ( ) ;
నా కుక్క. తినండి ( ) ; // అవుట్‌పుట్: జంతువులు తినడం
నా కుక్క. పరుగు ( ) ; // అవుట్‌పుట్: క్షీరదం నడుస్తున్నది
నా కుక్క. బెరడు ( ) ; // అవుట్‌పుట్: కుక్క మొరిగేది
}
}
ఇక్కడ కుక్క నుండి వారసత్వంగా పొందిన ఒక ఉత్పన్నమైన తరగతి క్షీరదం , ఇది క్రమంగా వారసత్వంగా పొందుతుంది జంతువు . డాగ్ క్లాస్ క్షీరదం మరియు జంతువు యొక్క అన్ని లక్షణాలు, పద్ధతులు మరియు ప్రవర్తనకు ప్రాప్యతను కలిగి ఉంది మరియు దాని స్వంత ప్రత్యేక పద్ధతిని కూడా నిర్వచించగలదు. బెరడు() .
ది జంతు తరగతి బేస్ క్లాస్ మరియు అనే పద్ధతిని కలిగి ఉంటుంది తినండి() , ఇది కన్సోల్‌కు జంతువు తినే సందేశాన్ని ప్రింట్ చేస్తుంది.
ది క్షీరద తరగతి జంతు తరగతి నుండి ఉద్భవించింది మరియు అనే పద్ధతిని జోడిస్తుంది రన్() , ఇది కన్సోల్‌కు నడుస్తున్న క్షీరద సందేశాన్ని ముద్రిస్తుంది.
ది కుక్క తరగతి క్షీరద తరగతి నుండి ఉద్భవించింది మరియు అనే పద్ధతిని జోడిస్తుంది బెరడు() , ఇది కన్సోల్‌కు కుక్క మొరిగే సందేశాన్ని ముద్రిస్తుంది.
ప్రధాన() పద్ధతి డాగ్ క్లాస్ అని పిలువబడే ఒక ఉదాహరణను సృష్టిస్తుంది నా కుక్క మరియు దాని ఈట్(), రన్(), మరియు బార్క్() పద్ధతులను పిలుస్తుంది.
ఈట్() మరియు రన్() పద్ధతులు డాగ్ క్లాస్‌లో నిర్వచించబడలేదని, కానీ దాని పేరెంట్ క్లాస్‌ల నుండి సంక్రమించాయని గమనించండి జంతువు మరియు క్షీరదం , వరుసగా. ది బెరడు() పద్ధతి కుక్క తరగతిలో మాత్రమే నిర్వచించబడింది.
క్రమానుగత వారసత్వం
క్రమానుగత వారసత్వంలో, విభిన్న సంఖ్యలో ఉత్పన్నమైన తరగతులు కేవలం ఒక బేస్ క్లాస్ నుండి వారసత్వంగా పొందబడతాయి. ఉదాహరణకి:
సిస్టమ్ ఉపయోగించి ;తరగతి ఆకారం
{
ప్రజా శూన్యం గీయండి ( )
{
కన్సోల్. రైట్ లైన్ ( 'డ్రాయింగ్ ఆకారం' ) ;
}
}
తరగతి సర్కిల్ : ఆకారం
{
ప్రజా శూన్యం పూరించండి ( )
{
కన్సోల్. రైట్ లైన్ ( 'ఫిల్లింగ్ సర్కిల్' ) ;
}
}
తరగతి స్క్వేర్ : ఆకారం
{
ప్రజా శూన్యం రంగు ( )
{
కన్సోల్. రైట్ లైన్ ( 'కలరింగ్ స్క్వేర్' ) ;
}
}
తరగతి కార్యక్రమం
{
స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
సర్కిల్ మై సర్కిల్ = కొత్త సర్కిల్ ( ) ;
నా సర్కిల్. గీయండి ( ) ; // అవుట్‌పుట్: డ్రాయింగ్ ఆకారం
నా సర్కిల్. పూరించండి ( ) ; // అవుట్‌పుట్: సర్కిల్ ఫిల్లింగ్
స్క్వేర్ మై స్క్వేర్ = కొత్త స్క్వేర్ ( ) ;
నా స్క్వేర్. గీయండి ( ) ; // అవుట్‌పుట్: డ్రాయింగ్ ఆకారం
నా స్క్వేర్. రంగు ( ) ; // అవుట్‌పుట్: కలరింగ్ స్క్వేర్
}
}
పై కోడ్‌లో, రెండూ వృత్తం మరియు చతురస్రం నుండి వారసత్వంగా పొందిన తరగతులు ఆకారం . వారు ఆకృతిలో నిర్వచించబడిన డ్రా() పద్ధతికి ప్రాప్యతను కలిగి ఉన్నారు మరియు వారి స్వంత ప్రత్యేక పద్ధతులను పూరించవచ్చు() మరియు రంగు()లను కూడా నిర్వచించగలరు.
ఇక్కడ మేము సర్కిల్ క్లాస్ అనే ఆబ్జెక్ట్‌ని సృష్టించాము నా సర్కిల్ మరియు ఒక వస్తువు చతురస్రం తరగతి పేరు నా స్క్వేర్ . మేము అప్పుడు కాల్ డ్రా() పద్ధతి, ఇది రెండు వస్తువులపై షేప్ క్లాస్ నుండి సంక్రమిస్తుంది.
తరువాత, మేము కాల్ చేస్తాము పూరించండి() మై సర్కిల్‌లోని పద్ధతి, ఇది సర్కిల్ క్లాస్‌కు ప్రత్యేకమైనది మరియు ది రంగు() మైస్క్వేర్‌లోని పద్ధతి, ఇది చదరపు తరగతికి ప్రత్యేకమైనది.
అవుట్‌పుట్ క్రింది విధంగా కన్సోల్‌కు ముద్రించబడుతుంది:
బహుళ వారసత్వం
బహుళ వారసత్వం అనేది బహుళ మూల తరగతుల నుండి ఉత్పన్నమైన తరగతి వారసత్వంగా పొందుతుంది. అయినప్పటికీ, C# బహుళ వారసత్వానికి మద్దతు ఇవ్వదు. సారూప్య కార్యాచరణను సాధించడానికి, C# ఉపయోగిస్తుంది ఇంటర్‌ఫేస్‌లు .
ముగింపు
C#లోని వారసత్వం ప్రాథమిక తరగతుల నుండి ప్రవర్తన మరియు కార్యాచరణను వారసత్వంగా పొందేందుకు తరగతులను అనుమతిస్తుంది. వారసత్వాన్ని ఉపయోగించి, మేము కోడ్‌ని మళ్లీ ఉపయోగించుకోవచ్చు మరియు ప్రోగ్రామ్‌లో క్రమానుగత ప్రవాహాన్ని సృష్టించవచ్చు. వివిధ రకాల వారసత్వాన్ని అర్థం చేసుకోవడం ద్వారా, నిర్వహించడం మరియు విస్తరించడం సులభం అయిన మరింత సమర్థవంతమైన మరియు వ్యవస్థీకృత కోడ్‌ను వ్రాయవచ్చు.