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