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