ఇది ఒక పద్ధతిలో లేదా కన్స్ట్రక్టర్‌లోని వస్తువును సూచించే కీవర్డ్. ఇది ప్రాథమికంగా ఉపయోగించబడుతుందిఒకే పేరుతో తరగతి గుణాలు మరియు పారామితుల మధ్య గందరగోళాన్ని తొలగించండి. ఈ వ్యాసంలో, యొక్క వివిధ అంశాలు మరియు ఉపయోగాలు మీకు చెప్తాను ఇది కీవర్డ్ లో .
ఈ వ్యాసంలో నేను కవర్ చేయబోయే విషయాలు క్రింద ఉన్నాయి:
- ఏమిటి ఇది జావాలో కీవర్డ్?
- ఎందుకు వాడాలి ఇది జావాలో కీవర్డ్?
- జావాలో ఈ కీవర్డ్ యొక్క ఉపయోగాలు
- యొక్క ముఖ్యమైన అంశాలు ఇది కీవర్డ్
జావాలో ఈ కీవర్డ్ ఏమిటి?
ఇది లో కీవర్డ్ ప్రస్తుతాన్ని సూచిస్తుంది . ఇది ప్రధానంగా ఒకే తరగతిలోని ఇతర సభ్యులను యాక్సెస్ చేయడానికి ఉపయోగించబడుతుంది. సహాయంతో ఇది కీవర్డ్, మీరు పద్ధతులు, ఫీల్డ్‌లు మరియు కన్స్ట్రక్టర్లు తరగతిలోని ఒకే తరగతి.
ఇప్పుడు, మరింత ముందుకు వెళ్లి, దాని అవసరం ఏమిటో అర్థం చేసుకుందాం ఇది జావాలో కీవర్డ్.
జావాలో ఈ కీవర్డ్‌ని ఎందుకు ఉపయోగించాలి?
యొక్క ప్రధాన నినాదం ఈ కీవర్డ్ ఉపయోగించి అధికారిక పరామితిని వేరు చేయడం మరియు తరగతి యొక్క. ఒకవేళ, తరగతి యొక్క అధికారిక పారామితి మరియు డేటా సభ్యులు ఒకేలా ఉంటే, అది అస్పష్టతకు దారితీస్తుంది. కాబట్టి, తరగతి యొక్క అధికారిక పరామితి మరియు డేటా సభ్యుల మధ్య తేడాను గుర్తించడానికి, తరగతి యొక్క డేటా సభ్యుడు ముందు “ ఇది ”కీవర్డ్.
హాష్ మ్యాప్ మరియు హాష్ టేబుల్ మధ్య తేడా ఏమిటి
సాధారణంగా, “ఇది” కీవర్డ్ను రెండు విధాలుగా ఉపయోగించవచ్చు.
ఇది.ఇది ()
1. ఇది.
దీనిని వేరు చేయడానికి ఉపయోగించవచ్చు మరియు పద్ధతి లేదా కన్స్ట్రక్టర్ యొక్క అధికారిక పారామితులు. అంతే కాదు, ఇది ఎల్లప్పుడూ ప్రస్తుత తరగతి వస్తువును సూచిస్తుంది. యొక్క సింటాక్స్ ఇది కీవర్డ్ క్రింద చూపిన విధంగా ఉంది:
సింటాక్స్
ప్రస్తుత తరగతి సభ్యుడు
గమనిక: ఏదైనా వేరియబుల్ ఉంటే ముందు “ఇది”, అప్పుడు JVM ఆ వేరియబుల్‌ను క్లాస్ వేరియబుల్‌గా పరిగణిస్తుంది .
2. ఇది ()
ఇది ఒకదాన్ని కాల్ చేయడానికి ఉపయోగించవచ్చు బిల్డర్ ఒకే తరగతి కోసం అనేకసార్లు వస్తువులను సృష్టించకుండా మరొకటి లోపల.
సింటాక్స్
ఈ () // పారామిటరైజ్డ్ లేదా డిఫాల్ట్ కన్స్ట్రక్టర్‌ను కాల్ చేయవద్దు (విలువ 1, విలువ 2, .....) // కాల్ పారామిటరైజ్డ్ కన్స్ట్రక్టర్
ఇప్పుడు మీకు ఏమిటో తెలుసు ఇది కీవర్డ్ మరియు మీకు ఇది ఎందుకు అవసరం, ఈ వ్యాసంలో లోతుగా డైవ్ చేద్దాం మరియు వివిధ అంశాలను అర్థం చేసుకుందాం ఇది లో కీవర్డ్ ఉపయోగించవచ్చు జావా .
ఈ కీవర్డ్ యొక్క ఉపయోగాలు
ఇక్కడ 6 మార్గాలు ఉన్నాయి ఈ కీవర్డ్ జావాలో ఉపయోగించవచ్చు. అవి ఈ క్రింది విధంగా ఉన్నాయి:
- ఫీల్డ్‌తో వాడతారు
- కన్స్ట్రక్టర్‌ను ప్రారంభించడానికి ఉపయోగిస్తారు
- ప్రస్తుత తరగతి ఉదాహరణను తిరిగి ఇవ్వడానికి ఉపయోగిస్తారు
- పద్ధతి పరామితిగా ఉపయోగించబడుతుంది
- ప్రస్తుత తరగతి పద్ధతిని ప్రారంభించడానికి ఉపయోగిస్తారు
- కన్స్ట్రక్టర్ కాల్‌లో వాదనగా ఉపయోగించబడుతుంది
ఇప్పుడు, ఈ ప్రతి పద్ధతుల వివరాలను తెలుసుకుందాం.
1. ఈ కీవర్డ్ను ఫీల్డ్ / వేరియబుల్ హైడింగ్‌తో ఉపయోగించవచ్చు
ఇది కీవర్డ్ లో చాలా సహాయపడుతుంది వేరియబుల్ దాచడం . ఇక్కడ, మీరు రెండు i ని సృష్టించలేరు అదే పేరుతో. ఏదేమైనా, ఒకే పేరుతో ఒక ఉదాహరణ వేరియబుల్ మరియు ఒక స్థానిక వేరియబుల్ సృష్టించడం సాధ్యపడుతుంది. ఈ సందర్భంలో, స్థానిక వేరియబుల్ ఉదాహరణ వేరియబుల్‌ను దాచగలదు. దీనిని అంటారు వేరియబుల్ దాచడం . ఇప్పుడు, ఉదాహరణ సహాయంతో దీన్ని మరింత వివరంగా అర్థం చేసుకుందాం.
ప్యాకేజీ ఎడురేకా దిగుమతి java.util. * పబ్లిక్ క్లాస్ ఫీల్డ్ {int j, n // పారామీటర్ చేయబడిన కన్స్ట్రక్టర్ టెస్ట్ (int j, int n) {this.j = j this.n = n} శూన్య ప్రదర్శన () {// విలువను ప్రదర్శిస్తుంది వేరియబుల్స్ j మరియు n System.out.println ('j =' + j + 'n =' + n)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఫీల్డ్ ఆబ్జ్ = కొత్త ఫీల్డ్ (27, 01) ఆబ్జెక్ట్ డిస్ప్లే ( )}}అవుట్పుట్:
j = 27 n = 01
పై ఉదాహరణలో, అధికారిక వాదనలు మరియు ఉదాహరణ వేరియబుల్స్ ఒకే విధంగా ఉంటాయి. అందువల్ల, ఈ వేరియబుల్స్ మధ్య తేడాను గుర్తించడానికి, నేను ఉపయోగించాను టి తన స్థానిక వేరియబుల్స్ అవుట్పుట్ చేయడానికి కీవర్డ్. కాబట్టి ఇది వేరియబుల్ దాచడం గురించి.
ఇప్పుడు ఎలా చూద్దాం ఇది కన్స్ట్రక్టర్‌ను ప్రారంభించడానికి జావాలోని కీవర్డ్ ఉపయోగించవచ్చు.
2. ఈ కీవర్డ్‌ని కన్స్ట్రక్టర్‌ను పిలవడానికి ఉపయోగించవచ్చు
ఈ () కన్స్ట్రక్టర్ కాల్ ప్రస్తుత తరగతి కన్స్ట్రక్టర్‌ను పిలవడానికి ఉపయోగించవచ్చు. కన్స్ట్రక్టర్‌ను తిరిగి ఉపయోగించటానికి కూడా దీనిని ఉపయోగించవచ్చు. మీరు ఈ పద్ధతిని కూడా పిలుస్తారు కన్స్ట్రక్టర్ చైనింగ్ . ఒక చిన్న ఉదాహరణ తీసుకుందాం మరియు ఎలా అర్థం చేసుకుందాం ఇది () వాడబడింది.
ప్యాకేజీ ఎడురేకా దిగుమతి java.util. * పబ్లిక్ క్లాస్ ఉదాహరణ {{int j, n // డిఫాల్ట్ కన్స్ట్రక్టర్ ఉదాహరణ () {ఇది (27, 01) System.out.println ('డిఫాల్ట్ కన్స్ట్రక్టర్ లోపల')} // పారామీటర్ చేయబడిన కన్స్ట్రక్టర్ ఉదాహరణ (int j, int n) {this.j = j this.n = n System.out.println ('పారామీటర్ చేయబడిన కన్స్ట్రక్టర్ లోపల')} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఉదాహరణ obj = new example ()} }అవుట్పుట్:
జావాలో పూర్ణాంకానికి రెట్టింపు
పారామీటర్ చేయబడిన కన్స్ట్రక్టర్ లోపల డిఫాల్ట్ కన్స్ట్రక్టర్ లోపల
పై ఉదాహరణలో, మీరు దీనిని చూడవచ్చు “ ఇది ఓవర్‌లోడ్ చేసిన కన్స్ట్రక్టర్‌ను అదే విధంగా అమలు చేయడానికి కీవర్డ్ ఉపయోగించబడుతుంది .
3. ప్రస్తుత తరగతి ఉదాహరణను తిరిగి ఇవ్వడానికి ఈ కీవర్డ్ ఉపయోగించవచ్చు
ఇక్కడ, మీరు తిరిగి రావచ్చు ఇది కీవర్డ్ పద్ధతి నుండి ఒక ప్రకటన. ఈ సందర్భంలో, పద్ధతి యొక్క రిటర్న్ రకం తప్పనిసరిగా తరగతి రకంగా ఉండాలి. ఉదాహరణ సహాయంతో దీన్ని అర్థం చేసుకుందాం.
పబ్లిక్ క్లాస్ ఎడురేకా {int j, int n // డిఫాల్ట్ కన్స్ట్రక్టర్ ఎడురేకా () {j = 100 n = 200} // ప్రస్తుత తరగతి ఉదాహరణను తిరిగి ఇచ్చే పద్ధతి ఎడురేకా పొందండి () this దీన్ని తిరిగి ఇవ్వండి // వేరియబుల్స్ యొక్క విలువను ప్రదర్శిస్తుంది j మరియు n శూన్యమైనవి display () {System.out.println ('j =' + j + 'n =' + n)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఎడురేకా ఆబ్ = కొత్త ఎడురేకా () ఆబ్జెక్ట్ (). ()}}అవుట్పుట్:
j = 100, n = 200
4. ఈ కీవర్డ్‌ని పద్దతి పరామితిగా ఉపయోగించవచ్చు
ఇది ఒకే తరగతి నుండి మరొక పద్ధతిని పిలవడానికి పద్ధతి లోపల కీవర్డ్ ఉపయోగించవచ్చు. క్రింద ఉదాహరణ అదే చూపిస్తుంది.
పబ్లిక్ క్లాస్ ఎడురేకా {int j, n // డిఫాల్ట్ కన్స్ట్రక్టర్ ఎడురేకా () {j = 100 n = 200} // 'ఈ' కీవర్డ్‌ని పారామితి శూన్య ప్రదర్శన (ఎడురేకా ఆబ్జెక్ట్) గా స్వీకరించే పద్ధతి {System.out.println ('j = '+ j +' n = '+ n)} // ప్రస్తుత తరగతి ఉదాహరణ శూన్యతను పొందే పద్ధతి () {ప్రదర్శన (ఇది)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {ఎడురేకా ఆబ్ = కొత్త ఎడురేకా () ఆబ్జెక్ట్. పొందండి ()}}అవుట్పుట్:
j = 100, n = 200
5. ఈ కీవర్డ్ ప్రస్తుత తరగతి పద్ధతిగా ఉపయోగించబడుతుంది
జావాలో స్ట్రింగ్ యొక్క డిఫాల్ట్ విలువ
ఇది ప్రస్తుత తరగతి యొక్క పద్ధతిని ప్రారంభించడానికి కీవర్డ్ ఉపయోగించవచ్చు. ఒక ఉదాహరణ సహాయంతో దాన్ని అర్థం చేసుకుందాం.
జఘన తరగతి ఎడురేకా {శూన్య ప్రదర్శన () {// కాలింగ్ ఫక్షన్ షో () this.show () System.out.println ('డిస్ప్లే ఫంక్షన్ లోపల')} శూన్య ప్రదర్శన () {System.out.println ('ఇన్సైడ్ షో ఫన్సియన్' )} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {ఎడురేకా j = కొత్త ఎడురేకా () j.display ()}}అవుట్పుట్:
లోపల ప్రదర్శన ఫంక్షన్ లోపల ప్రదర్శన ఫంక్షన్
6. ఈ కీవర్డ్ కన్స్ట్రక్టర్ కాల్‌లో ఆర్గ్యుమెంట్‌గా ఉపయోగించబడుతుంది
మీరు ఉత్తీర్ణత సాధించవచ్చు ఇది కన్స్ట్రక్టర్‌లో కూడా కీవర్డ్. మీరు ఒకదాన్ని ఉపయోగించాల్సి వస్తే ఇది ఉపయోగపడుతుంది బహుళ తరగతులలో. ఇప్పుడు ఉదాహరణ సహాయంతో అదే అర్థం చేసుకుందాం.
పబ్లిక్ క్లాస్ Y {X ఆబ్జ్ // పరామితి Y (X ఆబ్జెక్ట్) గా X // యొక్క వస్తువుతో పారామీటర్ చేయబడిన కన్స్ట్రక్టర్ {this.obj = obj // క్లాస్ X యొక్క కాలింగ్ డిస్ప్లే పద్ధతి obj.display ()}} క్లాస్ X {int x = 45 // X శూన్య ప్రదర్శన () యొక్క విలువను చూపించడానికి // కన్స్ట్రక్టర్ X () {Y obj = new Y (this) method // పద్ధతిలో దీనిని వాదనగా పంపడం ద్వారా Y // యొక్క వస్తువును సృష్టించే డిఫాల్ట్ కాంట్రాక్టర్. . System.out.println ('పదవ తరగతిలో x యొక్క విలువ:' + x)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {X ఆబ్జ్ = కొత్త X ()}} అవుట్పుట్ :
పదవ తరగతి: 45 లో x విలువ
ఈ కీవర్డ్ యొక్క ముఖ్యమైన అంశాలు:
మీరు కాల్ చేయాలి సూపర్ () మరియు ఇది () కన్స్ట్రక్టర్లలో మాత్రమే స్టేట్మెంట్లను పిలుస్తుంది మరియు అవి కన్స్ట్రక్టర్లలో మొదటి స్టేట్మెంట్ అయి ఉండాలి.
ఇది మమ్మల్ని వ్యాసం చివరకి తీసుకువస్తుంది ఇది జావాలో కీవర్డ్. మీరు దానిని సమాచారంగా కనుగొన్నారని నేను ఆశిస్తున్నాను.
చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, ఈ జావా ఇంటర్వ్యూ ప్రశ్నలతో పాటుగా, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని ఈ కీవర్డ్” వ్యాసంలోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.