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