ఈ బ్లాగ్ ఆచరణలో కోణ బ్రాకెట్లను ఉపయోగించే పద్ధతిని వివరిస్తుంది.
జావా జెనరిక్స్: యాంగిల్ బ్రాకెట్స్
జావాలోని కోణ బ్రాకెట్లు జెనరిక్స్‌ను నిర్వచించడానికి ఉపయోగించబడతాయి. అంటే యాంగిల్ బ్రాకెట్ కాల్ చేస్తున్నప్పుడు సాధారణ రకాన్ని మరియు తరగతిని పారామీటర్‌గా తీసుకుంటుంది. ఇది పేర్కొన్న పద్ధతి, తరగతులు మరియు విధులకు పరామితిని సెట్ చేయడానికి వినియోగదారు నిర్వచించిన, స్ట్రింగ్ మరియు పూర్ణాంకాలతో సహా వివిధ డేటా రకాలను అనుమతిస్తుంది. ఇంకా, HashSet, HashMap, ArrayList మొదలైన వివిధ తరగతులు జనరిక్‌లను ఉపయోగించుకున్నాయి. ఇది ఏ రకమైన డేటాతోనైనా ఉపయోగించవచ్చు.
ఉదాహరణ 1: క్లాస్‌తో కోణ బ్రాకెట్లు
ఈ ఉదాహరణలో, '' పేరుతో ఒక సాధారణ తరగతి సృష్టించబడింది. టెంప్ 'మరియు ఉపయోగిస్తుంది' <> ” పరామితి రకాన్ని పేర్కొనడానికి బ్రాకెట్లు. ఆ తర్వాత, ఒక వస్తువు ' టి ” సృష్టించబడింది/ప్రకటించబడింది. తరగతి పేరును ఉపయోగించి కన్స్ట్రక్టర్‌ను సృష్టించండి మరియు ''ని పాస్ చేయండి T obj ” ఈ కన్స్ట్రక్టర్‌కి పారామీటర్‌గా. ఇంకా, ' getObject() ఆబ్జెక్ట్‌ని పొందడానికి మరియు దానిని తిరిగి ఇవ్వడానికి పద్ధతిని అమలు చేస్తారు/అని పిలుస్తారు:
తరగతి టెంప్ < టి > {
T obj ;
టెంప్ ( T obj ) {
ఇది . obj = obj ;
}
ప్రజా T getObject ( ) {
తిరిగి ఇది . obj ;
}
}
లో ' ప్రధాన () ” మెయిన్ క్లాస్ యొక్క పద్ధతి, పూర్ణాంకాల డేటా రకం యొక్క ఉదాహరణను తయారు చేయండి, విలువను సెట్ చేయండి మరియు దానిని వేరియబుల్‌లో నిల్వ చేయండి:
టెంప్ < పూర్ణ సంఖ్య > iObj = కొత్త టెంప్ < పూర్ణ సంఖ్య > ( 30 ) ;
'ని పిలవండి println() 'పద్ధతి మరియు కాల్' getObject() 'ఆబ్జెక్ట్ వేరియబుల్‌తో పద్ధతి' iObj కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించడానికి:
వ్యవస్థ . బయటకు . println ( iObj. getObject ( ) ) ;
ఇప్పుడు, స్ట్రింగ్ రకం యొక్క ఉదాహరణ సృష్టించబడింది మరియు స్ట్రింగ్‌ను పారామీటర్‌గా పంపింది:
టెంప్ < స్ట్రింగ్ > sobj = కొత్త టెంప్ < స్ట్రింగ్ > ( 'Linuxhint ట్యుటోరియల్ వెబ్‌సైట్' ) ;కాల్ చేయడం ద్వారా వస్తువును పొందండి ' getObject() ” వాదనగా మరియు దానిని కన్సోల్‌లో ముద్రించండి:
వ్యవస్థ . బయటకు . println ( sobj. getObject ( ) ) ;
అవుట్‌పుట్
ఉదాహరణ 2: ఫంక్షన్‌తో కోణ బ్రాకెట్లు
జెనరిక్ మెథడ్‌కి పంపబడిన ఆర్గ్యుమెంట్‌ల రకాన్ని బట్టి వివిధ ఆర్గ్యుమెంట్ రకాలను ఉపయోగించి ఇన్‌వోక్ చేయబడే/కాల్ చేయబడే జెనరిక్ ఫంక్షన్‌లను కూడా మేము వ్రాయవచ్చు. అలా చేయడానికి, సాధారణ పద్ధతిని అమలు చేయండి ' జెనెరిక్ డిస్ప్లే() ” మరియు పరామితి రకాన్ని పేర్కొనండి. అప్పుడు, 'ని ఉపయోగించండి println() ” పద్ధతి మరియు కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించడానికి “getClass()”, “getName()” మరియు మూలకాన్ని ఆర్గ్యుమెంట్‌గా కాల్ చేయండి:
స్థిరమైన < టి > శూన్యం జెనెరిక్ డిస్ప్లే ( T మూలకం ) {వ్యవస్థ . బయటకు . println ( మూలకం. getClass ( ) . పేరు పొందండి ( ) + ' = ' + మూలకం ) ;
}
ఇప్పుడు, కన్సోల్‌లో ఫలితాన్ని ప్రదర్శించడానికి సాధారణ పద్ధతిని అమలు చేయండి మరియు పూర్ణాంక రకం ఆర్గ్యుమెంట్‌ను పాస్ చేయండి:
జెనెరిక్ డిస్ప్లే ( ఇరవై ఒకటి ) ;తరువాత, సాధారణ పద్ధతిని కాల్ చేయండి ' జెనెరిక్ డిస్ప్లే() ” స్ట్రింగ్ ఆర్గ్యుమెంట్‌తో:
జెనెరిక్ డిస్ప్లే ( 'Linuxhint ట్యుటోరియల్ వెబ్‌సైట్' ) ;చివరగా, సాధారణ పద్ధతిని ప్రారంభించండి ' జెనెరిక్ డిస్ప్లే() ద్వంద్వ వాదనతో:
జెనెరిక్ డిస్ప్లే ( 5.0 ) ;అవుట్‌పుట్
జావాలో కోణీయ బ్రాకెట్లను ఉపయోగించడం గురించి అంతే.
ముగింపు
జావాలోని కోణ బ్రాకెట్లు జెనరిక్స్‌ను నిర్వచించడానికి ఉపయోగించబడతాయి. కాల్ చేస్తున్నప్పుడు ఇది సాధారణ రకం మరియు తరగతిని పారామీటర్‌గా తీసుకుంటుంది. మీరు జావాలోని తరగతులతో పాటు ఫంక్షన్‌తో కోణ బ్రాకెట్లను ఉపయోగించుకోవచ్చు. ఇది పేర్కొన్న పద్ధతులు, తరగతులు మరియు ఫంక్షన్‌లకు పరామితిని సెట్ చేయడానికి వినియోగదారు నిర్వచించిన, స్ట్రింగ్ మరియు పూర్ణాంకాలతో సహా వివిధ డేటా రకాలను అనుమతిస్తుంది. ఈ పోస్ట్ జావాలో కోణ బ్రాకెట్లను ఉపయోగించడం గురించి పేర్కొంది.