ఈ కథనం జావాలో ఓవర్‌రైడింగ్ పద్ధతిని ఉపయోగించడం మరియు అమలు చేయడం గురించి వివరిస్తుంది.
జావాలో “మెథడ్ ఓవర్‌రైడింగ్” అంటే ఏమిటి?
చైల్డ్ క్లాస్ దాని పేరెంట్ క్లాస్‌లో పేర్కొన్న విధంగా అదే పద్ధతిని కలిగి ఉంటే, దానిని ' పద్ధతి భర్తీ ” జావాలో. అలా చేయడం ద్వారా, పిల్లల తరగతి యొక్క కార్యాచరణలు, అంటే, ఓవర్‌రైడ్ పద్ధతి అమలులోకి వస్తాయి.
జావాలో “మెథడ్ ఓవర్‌రైడింగ్” కోసం పరిగణనలు
- పద్ధతి తప్పనిసరిగా దాని పేరెంట్ క్లాస్‌లో ఉన్న పేరును కలిగి ఉండాలి.
- పద్ధతి దాని పేరెంట్ క్లాస్‌లో వలె ఒకే విధమైన పరామితిని కలిగి ఉండాలి.
- కేటాయించిన పద్ధతి ' చివరి ” ఓవర్‌రైడ్ చేయలేము.
ఉదాహరణ 1: జావాలో ఒక పద్ధతిని భర్తీ చేయడం
ఈ ఉదాహరణలో, ఒక పద్ధతిని భర్తీ చేసే పద్దతి, అంటే, “ ఫంక్షన్ వారసత్వం ద్వారా నిర్వహించవచ్చు:
తరగతి తల్లిదండ్రులు {
ప్రజా శూన్యం చూపించు ( ) {
వ్యవస్థ . బయటకు . println ( 'ఇది Linuxhint!' ) ;
} }
తరగతి పిల్లవాడు విస్తరించింది తల్లిదండ్రులు {
ప్రజా శూన్యం చూపించు ( ) {
వ్యవస్థ . బయటకు . println ( 'ఇది జావా!' ) ;
} }
ప్రజా తరగతి ఉదాహరణ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
చైల్డ్ obj = కొత్త పిల్లవాడు ( ) ;
obj చూపించు ( ) ;
} }
పై ప్రదర్శనలో, ఈ క్రింది దశలను వర్తింపజేయండి:
- ముందుగా, “పేరెంట్ (సూపర్) క్లాస్‌ని సృష్టించండి తల్లిదండ్రులు ”.
- ఈ తరగతిలో, '' అనే ఫంక్షన్‌ను నిర్వచించండి చూపించు() ” మరియు ఇచ్చిన సందేశాన్ని దాని(ఫంక్షన్) నిర్వచనంలో ప్రదర్శించండి.
- ఆ తర్వాత, '' అనే పిల్లల (ఉప) తరగతిని సృష్టించండి పిల్లవాడు 'వారసత్వంగా' తల్లిదండ్రులు 'ద్వారా తరగతి' విస్తరించింది ” కీవర్డ్.
- ఈ తరగతిలో, దాని పేరెంట్ క్లాస్‌లో నిర్వచించబడిన ఫంక్షన్‌ను ఒకే పేరుతో నిర్వచించడం ద్వారా భర్తీ చేయండి ' చూపించు() ” మరియు పేర్కొన్న సందేశాన్ని ప్రదర్శించండి.
- ప్రధానంగా, '' ద్వారా చైల్డ్ క్లాస్ యొక్క వస్తువును సృష్టించండి కొత్త 'కీవర్డ్ మరియు' పిల్లవాడు() ”నిర్మాణకర్త.
- చివరగా, ఫంక్షన్‌ను ప్రారంభించండి ' చూపించు() ” సృష్టించబడిన వస్తువును సూచించడం ద్వారా. ఇది పేరెంట్ క్లాస్‌లోని డిఫాల్ట్ ఫంక్షన్‌కు బదులుగా ఓవర్‌రైడ్ ఫంక్షన్‌ను అమలు చేస్తుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్‌లో, తరువాతి ఫంక్షన్ అంటే ఓవర్‌రైడ్ అమలులోకి వస్తుందని విశ్లేషించవచ్చు.
ఉదాహరణ 2: జావాను ఉపయోగించి ఓవర్‌రైడింగ్ పద్ధతిలో “సూపర్” కీవర్డ్‌ని ఉపయోగించడం
ఈ ప్రత్యేక ఉదాహరణలో, ' సూపర్ ” డిఫాల్ట్, అంటే పేరెంట్ మరియు ఓవర్‌రైడ్ పద్ధతి రెండింటి యొక్క కార్యాచరణలను అమలు చేయడానికి కీవర్డ్ అనుబంధించబడుతుంది:
తరగతి తల్లిదండ్రులు {ప్రజా శూన్యం చూపించు ( ) {
వ్యవస్థ . బయటకు . println ( 'ఇది Linuxhint!' ) ;
} }
తరగతి పిల్లవాడు విస్తరించింది తల్లిదండ్రులు {
ప్రజా శూన్యం చూపించు ( ) {
సూపర్ . చూపించు ( ) ;
వ్యవస్థ . బయటకు . println ( 'ఇది జావా!' ) ;
} }
ప్రజా తరగతి ఉదాహరణ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
చైల్డ్ obj = కొత్త పిల్లవాడు ( ) ;
obj చూపించు ( ) ;
} }
పై కోడ్ బ్లాక్‌లో:
- అదేవిధంగా, 'పేరెంట్ క్లాస్‌ని సృష్టించండి తల్లిదండ్రులు 'మరియు ఫంక్షన్‌ను కూడబెట్టు' చూపించు() ” అందులో, అందించిన సందేశాన్ని ప్రదర్శిస్తుంది.
- తదుపరి దశలో, '' పేరుతో పిల్లల తరగతిని సృష్టించండి పిల్లవాడు ” మాతృ తరగతి వారసత్వంగా.
- ఈ తరగతిలో, అదేవిధంగా, ఒకే విధమైన ఫంక్షన్‌ను భర్తీ చేయండి. అలాగే, అనుబంధించండి ' సూపర్ ”డిఫాల్ట్‌ను అమలు చేయడానికి ఫంక్షన్‌తో కూడిన కీవర్డ్, అనగా పేరెంట్ క్లాస్ ఫంక్షన్ యొక్క కార్యాచరణలు.
- చివరగా, చైల్డ్ క్లాస్ యొక్క ఆబ్జెక్ట్‌ను సృష్టించండి మరియు ఓవర్‌రైడ్ ఫంక్షన్‌ను ప్రారంభించండి.
- అల్గోరిథం: ఓవర్‌రైడ్ ఫంక్షన్‌ను ప్రారంభించినప్పుడు, మరియు ' సూపర్ ”కీవర్డ్ పేరెంట్ క్లాస్ ఫంక్షన్‌ని సూచిస్తుంది. ఇది కన్సోల్‌లో తల్లితండ్రులు మరియు పిల్లల తరగతులు రెండింటి యొక్క కార్యాచరణలను ఏకకాలంలో లాగ్ చేయడానికి దారి తీస్తుంది.
అవుట్‌పుట్
పై అవుట్‌పుట్, ఓవర్‌రైడ్ ఫంక్షన్ యొక్క ప్రభావాన్ని '' ద్వారా కూడా రద్దు చేయవచ్చని సూచిస్తుంది సూపర్ ” కీవర్డ్.
ఉదాహరణ 3: జావాలో “ఫైనల్” పద్ధతిని భర్తీ చేయడం
ఈ ఉదాహరణలో, ఒక ఫంక్షన్‌ను ఇలా కేటాయించవచ్చు చివరి ” పేరెంట్ క్లాస్‌లో మరియు తర్వాత దాని చైల్డ్ క్లాస్‌లో యాక్సెస్ చేయడం ద్వారా విశ్లేషించబడింది:
తరగతి తల్లిదండ్రులు {చివరి ప్రజా శూన్యం చూపించు ( ) {
వ్యవస్థ . బయటకు . println ( 'ఇది Linuxhint!' ) ;
} }
తరగతి పిల్లవాడు విస్తరించింది తల్లిదండ్రులు {
ప్రజా శూన్యం చూపించు ( ) {
వ్యవస్థ . బయటకు . println ( 'ఇది జావా!' ) ;
} }
ప్రజా తరగతి ఉదాహరణ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
చైల్డ్ obj = కొత్త పిల్లవాడు ( ) ;
obj చూపించు ( ) ;
} }
పైన అందించిన కోడ్ ప్రకారం, క్రింద ఇవ్వబడిన దశలను వర్తించండి:
- మాతృ తరగతిని సృష్టించండి ' తల్లిదండ్రులు ”.
- ఈ తరగతి లోపల, ఫంక్షన్ కేటాయించండి ' చూపించు() 'వలే' చివరి ”, మునుపటి కీవర్డ్ ద్వారా సూచించబడింది.
- ఇప్పుడు, పిల్లల తరగతిని వారసత్వంగా పొందండి ' పిల్లవాడు ” గతంలో చర్చించిన తరగతి నుండి. ఇక్కడ, కేటాయించిన వాటిని భర్తీ చేయండి ' చివరి ” మాతృ తరగతిలో ఫంక్షన్.
- ప్రధానంగా, '' యొక్క వస్తువును సృష్టించండి పిల్లవాడు ” క్లాస్ మరియు ఓవర్‌రైడ్ ఫంక్షన్‌ను ప్రారంభించండి.
అవుట్‌పుట్
పై కోడ్ అమలు చేయడం వలన ' చివరి ” పద్ధతిని భర్తీ చేయలేము.
ముగింపు
చైల్డ్ క్లాస్ దాని పేరెంట్ క్లాస్‌లో పేర్కొన్న విధంగా అదే పద్ధతిని కలిగి ఉంటే, అది జావాలో ఒక పద్ధతిని భర్తీ చేయడానికి అనుగుణంగా ఉంటుంది. ఈ విధానం మునుపటి పద్ధతులను భర్తీ చేస్తుంది మరియు రెండోదాన్ని అమలు చేస్తుంది. ఓవర్‌రైడింగ్‌ని '' ద్వారా అందించవచ్చు సూపర్ ' లేదా ' చివరి ” వివిధ మార్గాల్లో కీలకపదాలు. ఈ బ్లాగ్ జావాలో మెథడ్ ఓవర్‌రైడింగ్ భావన గురించి చర్చించింది.