జావాలో, ' వినియోగదారుడు ”ఇంటర్ఫేస్ అనేది ఒకే ఇన్‌పుట్‌ను స్వీకరించే ఆపరేషన్‌ను సూచిస్తుంది మరియు ఫలితం ఇవ్వకుండా దానిపై కొంత చర్యను చేస్తుంది. లాంబ్డా ఎక్స్‌ప్రెషన్‌ల వంటి ఫంక్షనల్ ప్రోగ్రామింగ్‌లో ఉపయోగించబడే అనుకూల కార్యకలాపాలను నిర్వచించడానికి ఇది సౌకర్యవంతమైన మార్గాన్ని కూడా అందిస్తుంది. ఈ బ్లాగ్ జావాలో వినియోగదారు ఇంటర్ఫేస్ అమలును వివరిస్తుంది.
జావాలో వినియోగదారు ఇంటర్‌ఫేస్‌ను ఎలా ఉపయోగించాలి?
ది ' వినియోగదారుడు ” ఇంటర్ఫేస్ ఎన్‌క్యాప్సులేషన్ లేదా బిహేవియర్‌ని అందజేస్తుంది, అది ప్రోగ్రామ్‌లోని వివిధ ప్రదేశాలలో అమలు చేయబడుతుంది. ఇది డూప్లికేట్ కోడ్ లేకుండా వివిధ ఇన్‌పుట్‌లకు వర్తించే పునర్వినియోగ ప్రవర్తనను ప్రోత్సహిస్తుంది. వినియోగదారు ఇంటర్ఫేస్ రెండు పద్ధతులను కలిగి ఉంటుంది, అవి “ ఆపై() 'మరియు' అంగీకరించు() ”.
కోడెక్ ఉదాహరణలతో పాటు రెండు ఫంక్షన్లను అర్థం చేసుకోవడానికి క్రింది ఉదాహరణలను సందర్శించండి:
ఉదాహరణ 1: “andThen()” పద్ధతిని ఉపయోగించడం
డెవలపర్ అనేక 'చైన్ చేయవచ్చు వినియోగదారుడు 'చర్యలు పూర్తిగా 'ని ఉపయోగించడం ద్వారా ఆపై() ” పద్ధతి. ఇది క్రొత్తదాన్ని తిరిగి ఇస్తుంది' వినియోగదారుడు 'ఇది కరెంట్ యొక్క ఆపరేషన్ చేస్తుంది' వినియోగదారుడు 'ఉదాహరణ. ఆ తర్వాత, రాబోయే/తర్వాత కార్యకలాపాలను పూర్తి చేస్తుంది “ వినియోగదారుడు 'ఉదాహరణ. ఇది '' ప్రక్రియ కోసం విస్తృతంగా ఉపయోగించబడే డిఫాల్ట్ పద్ధతి కూర్పు ”.
' కోసం వాక్యనిర్మాణం ఆపై() ” పద్ధతి క్రింద చేర్చబడింది:
ఆపై ( వినియోగదారుడు < ? సూపర్ టి > తర్వాత )
ది ' ఆపై() 'పద్ధతి ప్రస్తుత వినియోగదారుని మిళితం చేస్తుంది' సూపర్ 'మరొక వినియోగదారుతో' తర్వాత ”. మరియు ఇది ముందుగా ప్రస్తుత వినియోగదారు యొక్క ఆపరేషన్‌ను అమలు చేస్తుంది, ఆ తర్వాత అందించిన వినియోగదారు యొక్క ఆపరేషన్.
మెరుగైన అవగాహన కోసం ప్రోగ్రామ్ ద్వారా నడుద్దాం:
java.util.ArrayListని దిగుమతి చేయండి;java.util.LinkedListని దిగుమతి చేయండి;
java.util.Listని దిగుమతి చేయండి;
దిగుమతి java.util.function.Consumer;
పబ్లిక్ క్లాస్ రూట్ {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] )
{
// ప్రధాన పద్ధతి యొక్క సృష్టి
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > > multiply = dataEle - >
{
కోసం ( int j = 0 ; జె < dataEle.size ( ) ; j++ ) {
dataEle.set ( j, 5 * dataEle.get ( జె ) ) ;
}
} ;
// పూర్ణాంకాల జాబితాను ప్రదర్శించడానికి వినియోగదారు
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > >
ప్రింట్లు = dataEle - > dataEle.stream ( ) .ప్రతి ( k - > System.out.print ( k + '' ) ) ;
జాబితా < పూర్ణ సంఖ్య > dataEle = కొత్త అర్రేలిస్ట్ < పూర్ణ సంఖ్య > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
గుణించండి.మరియు ఆపై ( ప్రింట్లు ) .అంగీకరించు ( dataEle ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, ' వినియోగదారుడు ',' లింక్డ్లిస్ట్ ” మరియు సంబంధిత వినియోగాలు జావా ఫైల్‌లోకి దిగుమతి చేయబడతాయి. ఆ తరువాత, పేరుతో ప్రధాన తరగతి ' రూట్ ” సృష్టించబడింది.
- తరువాత, 'కన్స్యూమర్' అనే రకం జాబితా యొక్క ఇంటర్‌ఫేస్‌ను సృష్టించండి గుణించాలి 'మరియు దానిని 'కి సమానంగా సెట్ చేయండి అర్రేలిస్ట్ ” అది క్రింద సృష్టించబడుతుంది.
- ఇది ఉపయోగించుకుంటుంది ' కోసం 'లూప్' పొడవు వరకు పునరావృతమవుతుంది అర్రేలిస్ట్ ' అనే ' dataEle ', మరియు ' యొక్క ప్రతి డేటా మూలకాన్ని గుణిస్తుంది dataEle 'తో' 5 ”.
- ఆ తర్వాత ఒక సెకను ' వినియోగదారుడు ” ఇంటర్ఫేస్ సృష్టించబడింది, ఇది స్ట్రీమ్ నుండి గుణకార ప్రక్రియ తర్వాత తిరిగి పొందబడిన కన్సోల్‌లోని ప్రతి మూలకాన్ని ప్రింట్ చేస్తుంది.
- ఇప్పుడు, డమ్మీ డేటా ఎలిమెంట్లను సృష్టించి, జోడించండి dataEle ” అర్రేలిస్ట్.
- చివరికి, ' ఆపై() 'పద్ధతిని 'తో పిలుస్తారు అంగీకరించు() 'అంగీకరించే పద్ధతి' dataEle ” అర్రేలిస్ట్ మరియు ఫలితాన్ని అందిస్తుంది” గుణించాలి ” క్రమంలో.
అమలు దశ ముగిసిన తర్వాత:
'ని ఉపయోగించడం ద్వారా గుణకారం పని పూర్తయిందని స్నాప్‌షాట్ చూపిస్తుంది ఆపై() 'పద్ధతి' వినియోగదారుడు ' ఇంటర్ఫేస్.
ఉదాహరణ 2: “అంగీకరించు()” పద్ధతిని ఉపయోగించడం
ది ' అంగీకరించు() 'పద్ధతి' యొక్క క్రియాత్మక పద్ధతి వినియోగదారుడు ' ఇంటర్ఫేస్. ఇది ఒకే రకమైన వాదనను అంగీకరిస్తుంది ' టి ” మరియు దానిపై పేర్కొన్న/అవసరమైన కార్యకలాపాలను నిర్వహిస్తుంది. విలువ ' శూన్య 'అది అంగీకరించదు కాబట్టి దానికి అందించకూడదు' శూన్య ”విలువలు మరియు మినహాయింపును రూపొందించండి.
దీని వాక్యనిర్మాణం క్రింద ఇవ్వబడింది:
శూన్యం అంగీకరించండి ( < బలమైన > టి బలమైన > t )
పై వాక్యనిర్మాణంలో, “ t ” అనేది నిర్దిష్ట కార్యకలాపాలు నిర్వహించబడే ఏకైక వాదన.
మంచి అవగాహన కోసం దిగువ కోడ్ బ్లాక్‌ని సందర్శిద్దాం:
java.util.ArrayListని దిగుమతి చేయండి;java.util.LinkedListని దిగుమతి చేయండి;
java.util.Listని దిగుమతి చేయండి;
దిగుమతి java.util.function.Consumer;
// దిగుమతి వినియోగాలు లో జావా ఫైల్
పబ్లిక్ క్లాస్ రూట్ {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) // ప్రధాన పద్ధతి యొక్క సృష్టి
{
వినియోగదారుడు < పూర్ణ సంఖ్య > disp = k - > System.out.println ( కె ) ;
disp.accept ( 255 ) ;
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > > multiply = dataEle - >
{
కోసం ( int k = 0 ; కె < dataEle.size ( ) ; k++ )
dataEle.set ( k, 5 * dataEle.get ( కె ) ) ;
} ;
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > >
ప్రింట్లు = dataEle - > dataEle.stream ( ) .ప్రతి ( j - > System.out.print ( j + '
' ) ) ;
జాబితా < పూర్ణ సంఖ్య > dataEle = కొత్త అర్రేలిస్ట్ < పూర్ణ సంఖ్య > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// ఆమోదించడాన్ని ఉపయోగించి సవరించడాన్ని అమలు చేయండి ( )
గుణించండి.అంగీకరించండి ( dataEle ) ;
// అంగీకరించడం ఉపయోగించి డిస్ప్‌లిస్ట్‌ని అమలు చేయండి ( )
prints.accept ( dataEle ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, ' వినియోగదారుడు 'ఇంటర్ఫేస్ పేరు' disp ” ఏ ఆపరేషన్ చేయకుండానే కన్సోల్‌లో అందించిన పారామితులను ప్రదర్శించే సృష్టించబడుతుంది.
- ఇప్పుడు, ' అంగీకరించు() 'పద్ధతిని' అంటారు disp 'వినియోగదారు, మరియు విలువ' 255 ” ఈ పద్ధతికి పంపబడింది.
- తరువాత, మరొక ' వినియోగదారుడు 'ఇంటర్ఫేస్ సృష్టించబడింది, ఇది 'ని ఉపయోగిస్తుంది కోసం 'అరేలిస్ట్ యొక్క ప్రతి నివాస మూలకంపై గుణకారం వర్తింపజేయడానికి లూప్' అనే పేరు dataEle ”.
- ఆ తర్వాత, మరొకదాన్ని సృష్టించండి ' వినియోగదారుడు 'ఇంటర్ఫేస్ ప్రదర్శించడానికి' dataEle స్ట్రీమ్ నుండి వచ్చే గుణకారాన్ని వర్తింపజేసిన తర్వాత మూలకాలు ఏర్పడతాయి.
- తరువాత, అర్రేలిస్ట్ ప్రారంభించండి ' dataEle 'డమ్మీ డేటా ఎలిమెంట్స్‌తో మరియు 'ని ఉపయోగించండి అంగీకరించు() 'తో పద్ధతి' గుణించాలి ' ఇంటర్ఫేస్.
- చివరికి, కాల్ చేయండి ' అంగీకరించు() 'ఉపయోగించే పద్ధతి' ప్రింట్లు ” కన్సోల్ లాగ్‌పై గుణకారాన్ని వర్తింపజేసిన తర్వాత ఫలితాన్ని ప్రదర్శించడానికి ఇంటర్ఫేస్.
అమలు ముగిసిన తర్వాత:
' అంగీకరించు() ” పద్ధతి.
ఉదాహరణ 3: తర్వాత ఫంక్షన్ కోసం మినహాయింపు నిర్వహణ
మినహాయింపు ఏర్పడినప్పుడు ' తర్వాత 'ఫంక్షన్' ఆపై() 'పద్ధతిలో ఒక' ఉంటుంది అంగీకరించు() ” పద్ధతి. ఇది దిగువ చూపిన విధంగా వినియోగదారు ఇంటర్ఫేస్ పద్ధతులను ఉపయోగించి ఇంటర్‌ఫేస్‌ల ద్వారా ప్రాసెస్ చేయబడే డేటాను కలిగి ఉండే ఇంటర్‌ఫేస్‌ను చేస్తుంది:
java.util.ArrayListని దిగుమతి చేయండి;java.util.LinkedListని దిగుమతి చేయండి;
java.util.Listని దిగుమతి చేయండి;
దిగుమతి java.util.function.Consumer;
పబ్లిక్ క్లాస్ రూట్ {
పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] )
{
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > > గుణించాలి = dataEle - >
{
కోసం ( int j = 0 ; జె < = dataEle.size ( ) ; j++ )
dataEle.set ( j, 5 * dataEle.get ( జె ) ) ;
} ;
// పూర్ణాంకాల జాబితాను ప్రదర్శించడానికి వినియోగదారు
వినియోగదారుడు < జాబితా < పూర్ణ సంఖ్య > >
ముద్రణ = dataEle - > dataEle.stream ( ) .ప్రతి ( నేను - > System.out.print ( నేను + '' ) ) ;
జాబితా < పూర్ణ సంఖ్య > dataEle = కొత్త అర్రేలిస్ట్ < పూర్ణ సంఖ్య > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
ప్రయత్నించండి {
print.and then ( గుణించాలి ) .అంగీకరించు ( dataEle ) ;
}
క్యాచ్ ( మినహాయింపు ఇ ) {
System.out.println ( 'మినహాయింపు: ' + మరియు ) ;
}
}
}
పై కోడ్ బ్లాక్ యొక్క వివరణ:
- మొదట, ' వినియోగదారుడు 'ఇంటర్ఫేస్ సృష్టించబడింది, ఇది కేవలం బహుళ' 5 ” అందించిన అర్రేలిస్ట్‌లో ఉన్న డేటా మూలకాలతో పూర్ణాంకాలు.
- తరువాత, రెండవది ' వినియోగదారుడు ” స్ట్రీమ్ ద్వారా స్వీకరించబడిన అర్రేలిస్ట్ యొక్క ప్రతి డేటా మూలకాన్ని ప్రదర్శించడానికి ఇంటర్ఫేస్ సృష్టించబడింది.
- ఆ తర్వాత, అర్రేలిస్ట్ డమ్మీ పూర్ణాంకాల రకం విలువలతో సృష్టించబడుతుంది మరియు ప్రారంభించబడుతుంది.
- అప్పుడు, ' ప్రయత్నించండి 'బ్లాక్ ఉపయోగించబడుతుంది, దీనిలో' ఆపై() 'పద్ధతిని' అంటారు ముద్రణ ' ఇంటర్ఫేస్.
- ఇది కారణమవుతుంది ' IndexOutOfBoundsException ' ఎందుకంటే ' కోసం 'లూప్ పునరావృత పరిమితి మించిపోయింది, దీని ద్వారా పరిష్కరించబడుతుంది' క్యాచ్ ”బ్లాక్.
అమలు దశ ముగిసిన తర్వాత:
IndexOutOfBoundsException కంపైలర్ ద్వారా రూపొందించబడిందని స్నాప్‌షాట్ చూపిస్తుంది.
ముగింపు
ది ' వినియోగదారుడు ” ఇంటర్ఫేస్ పునర్వినియోగ ప్రవర్తనను నిర్వచించడానికి మరియు ఫలితాన్ని అందించకుండా ఇన్‌పుట్ డేటాపై చర్యలను నిర్వహించడానికి ఒక మార్గాన్ని అందిస్తుంది. ఇది కలిగి ' అంగీకరించు() 'మరియు' ఆపై() ” పద్ధతులు. ఇది తరచుగా డేటా ప్రాసెసింగ్ టాస్క్‌ల కోసం ఉపయోగించబడుతుంది, ఇక్కడ వినియోగదారులు సేకరణ లేదా స్ట్రీమ్‌లోని ప్రతి మూలకంపై చర్యను నిర్వహించాలి. జావాలో వినియోగదారు ఇంటర్ఫేస్ వినియోగం మరియు అమలు గురించి అంతే.