జావాలో, ' విస్తరించింది 'మరియు' అమలు చేస్తుంది 'బహుళ ఫంక్షనాలిటీలను సమర్ధవంతంగా సమగ్రపరచడంలో కీలకపదాలు చాలా ముఖ్యమైనవి. ఉదాహరణకు, వాటిని నవీకరించడానికి ఇప్పటికే కేటాయించిన కార్యాచరణలను వారసత్వంగా పొందడం లేదా వరుసగా డేటాను తగిన పద్ధతిలో క్రమబద్ధీకరించడం. అటువంటి సందర్భాలలో, డెవలపర్ చివరిలో విషయాలను సౌకర్యవంతంగా చేయడానికి మరియు వనరులను సమర్ధవంతంగా నిర్వహించడానికి 'విస్తరిస్తుంది' మరియు 'అమలు' కీలకపదాలు సహాయపడతాయి.
ఈ బ్లాగ్ జావా 'విస్తరిస్తుంది' మరియు 'అమలు' మధ్య తేడాలను హైలైట్ చేస్తుంది.
జావా 'విస్తరిస్తుంది' కీవర్డ్
జావా' విస్తరించింది 'కీవర్డ్ చైల్డ్ క్లాస్ ద్వారా ఉపయోగించబడుతుంది, అనగా,' ఉద్భవించింది 'తల్లిదండ్రుల తరగతిని వారసత్వంగా పొందేందుకు, అనగా,' బేస్ ” దాని కార్యాచరణలను యాక్సెస్ చేయడం ద్వారా.
వాక్యనిర్మాణం
తరగతి A {
// శరీరం
}
తరగతి B విస్తరిస్తుంది A {
// శరీరం
}
ఈ వాక్యనిర్మాణంలో, ' బి 'మాతృ తరగతిని వారసత్వంగా పొందుతున్న పిల్లల తరగతికి అనుగుణంగా ఉంటుంది' ఎ 'ద్వారా' విస్తరించింది ” కీవర్డ్.
ఉదాహరణ 1: జావాలో “విస్తరిస్తుంది” కీవర్డ్‌ని ఉపయోగించడం
ఈ ఉదాహరణ 'ని ఉపయోగిస్తుంది విస్తరించింది 'తల్లిదండ్రులను వారసత్వంగా పొందేందుకు కీలకపదం అంటే,' బేస్ 'తరగతి:
తరగతి పేరెంట్‌క్లాస్ {స్ట్రింగ్ x = 'జుట్టు' ;
}
తరగతి చైల్డ్‌క్లాస్ పేరెంట్‌క్లాస్‌ను విస్తరిస్తుంది {
పబ్లిక్ స్ట్రింగ్ కాన్కాట్ ( ) {
తిరిగి x.concat ( 'రై' ) ;
} }
పబ్లిక్ క్లాస్ విస్తరిస్తుంది {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
చైల్డ్ క్లాస్ ఆబ్జెక్ట్ = కొత్త పిల్లల తరగతి ( ) ;
System.out.println ( వస్తువు.సంఘటన ( ) ) ;
} }
పై కోడ్ స్నిప్పెట్ ప్రకారం, క్రింది దశలను వర్తింపజేయండి:
- ముందుగా, 'పేరెంట్ క్లాస్‌ని ప్రకటించండి పేరెంట్‌క్లాస్ ”.
- దాని నిర్వచనంలో, పేర్కొన్న వేరియబుల్‌ను ప్రారంభించండి.
- ఇప్పుడు, మాతృ తరగతి నుండి పిల్లల తరగతిని వారసత్వంగా పొందండి “ విస్తరించింది ” కీవర్డ్.
- చైల్డ్ క్లాస్ డెఫినిషన్‌లో, '' అనే ఫంక్షన్‌ను నిర్వచించండి concat() ”.
- ఫంక్షన్ డెఫినిషన్‌లో, పేరెంట్ క్లాస్ నుండి వేరియబుల్‌ను ప్రారంభించండి మరియు అనుబంధిత “ ద్వారా పేర్కొన్న స్ట్రింగ్‌ను జోడించండి concat() ” పద్ధతి.
- లో ' ప్రధాన () 'పద్ధతి, 'ని ఉపయోగించి పిల్లల తరగతి వస్తువును సృష్టించండి కొత్త 'కీవర్డ్ మరియు' పిల్లల తరగతి() ”నిర్మాణకర్త.
- చివరగా, చైల్డ్ క్లాస్ ఫంక్షన్‌ను ప్రారంభించండి ' concat() ” సృష్టించిన వస్తువు ద్వారా.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, పేరెంట్ క్లాస్ ఫంక్షనాలిటీ అంటే, ' వేరియబుల్(x) 'విస్తరిస్తుంది' కీవర్డ్ ద్వారా సముచితంగా సంక్రమించబడుతుంది కాబట్టి స్ట్రింగ్ తదనుగుణంగా సంగ్రహించబడుతుంది.
జావా 'అమలు' కీవర్డ్
ది ' అమలు చేస్తుంది ” కీవర్డ్ క్లాస్‌లో ఇంటర్ఫేస్ను అదే లేదా బాహ్య ఫైల్ నుండి అమలు చేయడానికి వర్తించబడుతుంది.
వాక్యనిర్మాణం
పబ్లిక్ ఇంటర్ఫేస్ ఇంటర్ఫేస్ పేరు {శూన్యం x ( ) ;
డిఫాల్ట్ శూన్యం y ( ) {
// శరీరం
}
}
క్లాస్ z ఇంటర్ఫేస్ నేమ్‌ని అమలు చేస్తుంది {
// తరగతి శరీరం
}
ఈ వాక్యనిర్మాణంలో:
- ' x ” అనేది ఒక వియుక్త పద్ధతిని సూచిస్తుంది.
- ' మరియు ” డిఫాల్ట్ పద్ధతిని సూచిస్తుంది.
- ' తరగతి z 'ని అమలు చేసే తరగతికి అనుగుణంగా ఉంటుంది' ఇంటర్ఫేస్ పేరు '' ద్వారా ఇంటర్ఫేస్ అమలు చేస్తుంది ” కీవర్డ్.
ఉదాహరణ 2: జావాలో “అమలు” కీవర్డ్‌ని ఉపయోగించడం
ఈ ప్రత్యేక ఉదాహరణలో, ఒక ఇంటర్ఫేస్ ' నైరూప్య 'మరియు' డిఫాల్ట్ ” పద్ధతులను తరగతిలో అమలు చేయవచ్చు.
ఇంటర్ఫేస్ కోడ్
పబ్లిక్ ఇంటర్ఫేస్ వయస్సు {పబ్లిక్ శూన్యం పేరు ( ) ;
డిఫాల్ట్ శూన్యం DOB ( ) {
System.out.println ( 'DOB -> 28/8/1999' ) ;
} }
పై ఇంటర్ఫేస్ కోడ్‌లో, '' అనే నైరూప్య పద్ధతిని చేర్చండి పేరు() 'మరియు డిఫాల్ట్ పద్ధతిని నిర్వచించండి' DOB() ” వరుసగా పేర్కొన్న సందేశాన్ని ముద్రించడం.
తరగతి కోడ్
ఇప్పుడు, కోడ్ యొక్క క్రింది పంక్తులకు వెళ్లండి:
తరగతి నమూనా వయస్సును అమలు చేస్తుంది {పబ్లిక్ శూన్యం పేరు ( ) {
System.out.println ( 'పేరు -> డేవిడ్' ) ;
} }
పబ్లిక్ క్లాస్ ఇంటర్ఫేస్2 {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
నమూనా వస్తువు = కొత్త నమూనా ( ) ;
వస్తువు.పేరు ( ) ;
వస్తువు.DOB ( ) ;
} }
ఈ కోడ్ బ్లాక్‌లో:
- ' అనే తరగతిని నిర్వచించండి నమూనా 'ఇంటర్ఫేస్ను అమలు చేయడం' వయస్సు 'ద్వారా' అమలు చేస్తుంది ” కీవర్డ్.
- దాని (తరగతి) నిర్వచనంలో, వియుక్త పద్ధతిని నిర్వచించండి ' పేరు() ” పేర్కొన్న పేరును ప్రదర్శించే ఇంటర్‌ఫేస్‌లో పేర్కొనబడింది.
- లో ' ప్రధాన () ” పద్ధతి, చర్చించబడిన విధానం ద్వారా తరగతి వస్తువును సృష్టించండి.
- చివరగా, సృష్టించబడిన వస్తువును ఉపయోగించి వరుసగా వియుక్త మరియు డిఫాల్ట్ పద్ధతులను ప్రారంభించండి.
అవుట్‌పుట్
డిఫాల్ట్ పద్ధతి అమలు చేయబడిందని మరియు అమలు చేయబడిన ఇంటర్ఫేస్ ఆధారంగా వియుక్త పద్ధతి తగిన విధంగా వర్తింపజేయబడుతుందని ఈ ఫలితం సూచిస్తుంది.
జావాలో 'విస్తరిస్తుంది' మరియు 'అమలు' మధ్య ప్రధాన తేడాలు
జావాలోని “విస్తరిస్తుంది” మరియు “అమలు” కీవర్డ్‌ల మధ్య కొన్ని ప్రధాన వ్యత్యాసాలు క్రింది విధంగా ఉన్నాయి:
| విస్తరించింది | అమలు చేస్తుంది |
| ఈ కీవర్డ్ దాని పేరెంట్ క్లాస్‌ను వారసత్వంగా పొందేందుకు తరగతి లేదా ఇతర ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందేందుకు ఇంటర్ఫేస్ ద్వారా ఉపయోగించబడుతుంది. | ఒక తరగతి 'ఇంప్లిమెంట్స్' కీవర్డ్ ద్వారా ఇంటర్ఫేస్ను అమలు చేయగలదు. |
| ఒక తరగతి ద్వారా ఒక పేరెంట్ క్లాస్ మాత్రమే పొడిగించబడుతుంది. | ఒక తరగతి ఒకేసారి బహుళ ఇంటర్‌ఫేస్‌లను అమలు చేయగలదు/వర్తింపజేయగలదు. |
| పేరెంట్ క్లాస్‌ని విస్తరించే పిల్లల తరగతికి పేరెంట్ క్లాస్‌లోని అన్ని పద్ధతులను భర్తీ చేయడం తప్పనిసరి కాదు. | ఇంటర్ఫేస్ను అమలు చేసే తరగతి అన్ని ఇంటర్ఫేస్ పద్ధతులను కూడా అమలు చేయడం/వర్తించడం తప్పనిసరి. |
ముగింపు
ది ' విస్తరించింది 'కీవర్డ్‌ని దాని పేరెంట్ క్లాస్ లేదా ఇతర ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందడానికి క్లాస్ లేదా ఇంటర్ఫేస్ ఉపయోగించవచ్చు, అయితే ' అమలు చేస్తుంది ” కీవర్డ్ ఇంటర్‌ఫేస్‌ని అమలు చేయడానికి తరగతిచే ఉపయోగించబడుతుంది. ఈ బ్లాగ్ ఆచరణాత్మక ఉదాహరణల సహాయంతో జావాలో 'విస్తరిస్తుంది' మరియు 'అమలు' మధ్య తేడాలను ప్రదర్శించింది.