జావాలో లాజికల్ మరియు రిలేషనల్ ఆపరేటర్లకు బిగినర్స్ గైడ్

ఆపరేటర్లు విలువలు, వేరియబుల్స్ లేదా స్టేట్‌మెంట్‌లపై కార్యకలాపాలను నిర్వహించడానికి ఉపయోగించే చిహ్నాలు. వారు ఈ చర్యలను చేసే వ్యక్తీకరణలను ఆపరేండ్లు అంటారు. కార్యకలాపాలు సంబంధిత, సమానత్వం మరియు తార్కిక ఆపరేటర్‌ల కోసం బూలియన్ ఫలితాన్ని (నిజం లేదా తప్పు) అందిస్తాయి.

ఆపరేటర్ తీసుకునే ఆపరేండ్ల సంఖ్య దాని రకాన్ని నిర్ణయిస్తుంది. ఒక ఆపరేండ్‌ని తీసుకునే ఆపరేటర్‌ను 'యునరీ' అంటారు. రెండు ఆపరేండ్లను తీసుకునే ఆపరేటర్‌ను 'బైనరీ' అంటారు.

---

---

మీరు జావాలో లాజికల్ మరియు రిలేషనల్ ఆపరేటర్‌లను ఎలా ఉపయోగించవచ్చో తెలుసుకోవడానికి చదవండి. ఇంకా మంచిది, చాలా ప్రోగ్రామింగ్ భాషలు ఒకే ఆపరేటర్‌లను ఉపయోగిస్తాయి కాబట్టి మీరు ఈ పరిజ్ఞానాన్ని వేరే చోట అన్వయించవచ్చు.

లాజికల్ ఆపరేటర్లు

ప్రోగ్రామింగ్ చేసేటప్పుడు లాజికల్ స్టేట్‌మెంట్‌లను రూపొందించడానికి అవి ఉపయోగించబడతాయి. జావాలో ఆరు లాజికల్ ఆపరేటర్లు ఉన్నారు. దిగువ పట్టిక వాటిని సంగ్రహిస్తుంది.

ఆపరేటర్	పేరు	టైప్ చేయండి
|	బూలియన్ లాజికల్ లేదా	బైనరీ
&	బూలియన్ లాజికల్ మరియు	బైనరీ
ఐ	బూలియన్ లాజికల్ ఎక్స్‌క్లూజివ్ లేదా	బైనరీ
||	షరతులతో కూడిన లేదా	బైనరీ
&&	షరతులతో కూడిన మరియు	బైనరీ
!	లాజికల్ కాదు	యునరీ

మీరు ఒకటి లేదా రెండు షరతులు నిజమా కాదా అని తనిఖీ చేయాలనుకుంటే, ఈ ఆపరేటర్‌ని ఉపయోగించండి. ఒక షరతు అనేది నిజం లేదా అబద్ధం కావచ్చు.

బూలియన్ లాజికల్ కలుపుకొని లేదా (|)

తార్కిక OR వ్యక్తీకరణను మూల్యాంకనం చేయడానికి ముందు రెండు ఒపెరాండ్‌లు నిజమేనా అని తనిఖీ చేస్తుంది.

if ( dob <2005 | height <= 5){
money++;
}

పై ఉదాహరణ ఎవరికైనా వారి పుట్టిన తేదీ (డాబ్) 2005 కంటే తక్కువగా ఉంటే లేదా వారి ఎత్తు 5 అడుగుల కంటే తక్కువ లేదా సమానంగా ఉంటే ఎక్కువ డబ్బును ఇస్తుంది.

---

---

బూలియన్ లాజికల్ మరియు (&)

ఈ ఆపరేటర్ ప్రోగ్రామ్‌లో నిర్దిష్ట అమలు మార్గాన్ని తీసుకునే ముందు రెండు షరతులు నిజమేనా అని తనిఖీ చేయడానికి ఉపయోగిస్తారు. మొత్తం వ్యక్తీకరణను మూల్యాంకనం చేయడానికి ముందు రెండు పరిస్థితులు నిజమేనా అని ఇది మొదట తనిఖీ చేస్తుంది.

సంబంధిత: పైథాన్‌లో బూలియన్ పద్ధతులను ఉపయోగించి తీగలను ఎలా ధృవీకరించాలి

---

---

బూలియన్ లాజికల్ ఎక్స్‌క్లూజివ్ OR (^)

మీరు షరతులలో ఒకటి నిజమా కాదా అని తనిఖీ చేయాలనుకుంటే, రెండూ కాకపోతే, ఇది ఉపయోగించడానికి ఆపరేటర్. దిగువ సత్యం పట్టిక మీరు ఉపయోగించినప్పుడు మీరు చూసే ఫలితాలను సంగ్రహిస్తుంది.

వ్యక్తీకరణ 1	వ్యక్తీకరణ 2	వ్యక్తీకరణ 1 ^ వ్యక్తీకరణ 2
తప్పుడు	తప్పుడు	తప్పుడు
తప్పుడు	నిజం	నిజం
నిజం	తప్పుడు	నిజం
నిజం	నిజం	తప్పుడు

బూలియన్ షరతులతో కూడిన మరియు (&&)

ఈ ఆపరేటర్ లాజికల్ AND కి సమానంగా ఉంటుంది. వ్యత్యాసం ఏమిటంటే, కుడి వైపున ఉన్నదాన్ని తనిఖీ చేయడానికి ముందు ఎడమవైపు ఉన్న పరిస్థితి నిజమేనా అని తనిఖీ చేస్తుంది.

ఎడమ భాగం తప్పు అని తేలితే, అమలు వెంటనే ఆగిపోతుంది. లేకపోతే, కుడి భాగం యొక్క మూల్యాంకనం కొనసాగుతుంది. ఈ లక్షణాన్ని షార్ట్ సర్క్యూట్ మూల్యాంకనం అంటారు.

ఈ ఆపరేటర్‌పై మీ అవగాహన కోసం కింది సత్యం పట్టికను చూడండి.

వ్యక్తీకరణ 1	వ్యక్తీకరణ 2	వ్యక్తీకరణ 1 && వ్యక్తీకరణ 2
తప్పుడు	తప్పుడు	తప్పుడు
తప్పుడు	నిజం	తప్పుడు
నిజం	తప్పుడు	తప్పుడు
నిజం	నిజం	నిజం

షరతులతో కూడిన OR (||)

ఒకవేళ ఏవైనా షరతులు తప్పు అయితే, అమలు కార్యక్రమం యొక్క తదుపరి భాగానికి దాటవేయబడుతుంది. మరో మాటలో చెప్పాలంటే, రెండు షరతులు తప్పనిసరిగా నిజం కావాలి.

ఈ ఆపరేటర్ లాజికల్ OR లాగానే ఉంటుంది. నిర్దిష్ట కోడ్‌ను అమలు చేయడానికి ముందు ఒకటి లేదా రెండు షరతులు నిజమేనా అని కూడా ఇది తనిఖీ చేస్తుంది.

షరతులతో కూడిన AND లాగానే, లాజికల్ OR కూడా షార్ట్ సర్క్యూట్ మూల్యాంకనాన్ని ఉపయోగిస్తుంది. కుడి వైపున ఉన్నదాన్ని విశ్లేషించడానికి ముందు ఎడమ వైపున ఉన్న ఒపెరాండ్ నిజమేనా అని ఇది ముందుగా చెక్ చేస్తుంది.

సంబంధిత: జావాలో కన్స్ట్రక్టర్ అంటే ఏమిటి మరియు మీరు దానిని ఎలా ఉపయోగిస్తున్నారు?

స్నాప్‌చాట్‌లో స్ట్రీక్‌ను త్వరగా పొందడం ఎలా

ఎడమవైపు ఉన్న పరిస్థితి నిజమని తేలితే, కుడివైపున ఉన్నదాన్ని తనిఖీ చేయవలసిన అవసరం లేదు. లేకపోతే, కుడివైపు మూల్యాంకనం కొనసాగుతుంది.

లాజికల్ NOT (!)

ఈ ఆపరేటర్ పరిస్థితిని తిరస్కరించడానికి ఉపయోగించబడుతుంది. ఇది కేవలం అది పనిచేస్తున్న దాని అర్థాన్ని రివర్స్ చేస్తుంది.

if(!(x>5)){
// statements
}

పై ప్రకటన అంటే 'x 5 కంటే ఎక్కువ' నిజం కాకపోతే, స్టేట్‌మెంట్‌లను లోపల అమలు చేయండి ఉంటే .

వ్యక్తీకరణ (x> 5) తో రౌండ్ బ్రాకెట్ల వాడకాన్ని గమనించండి. మీ ప్రోగ్రామ్ రాసేటప్పుడు మీరు ఈ బ్రాకెట్లను చేర్చకపోతే, మీకు కంపైల్-టైమ్ ఎర్రర్ వస్తుంది. కారణం ఎందుకంటే ! ఒక షరతుపై పనిచేసే ఒక unary ఆపరేటర్. బ్రాకెట్‌లు లేకుండా, కంపైలర్ దీనిని x> 5 కాకుండా x లో పనిచేసే ఆపరేటర్‌గా అర్థం చేసుకుంటుంది.

బ్రాకెట్లను చేర్చడం అనేది ఒక వ్యక్తీకరణను సరిగ్గా అర్థం చేసుకోవడానికి కంపైలర్‌ను ఎనేబుల్ చేయడం కోసం మాత్రమే కాదు. ప్రోగ్రామర్‌కి మరింత క్లిష్టమైన వ్యక్తీకరణలను బాగా అర్థం చేసుకోవడానికి వాటిని ఒక మార్గంగా కూడా ఉపయోగించవచ్చు. దిగువ ఉదాహరణను చూడండి:

age >= 7 && height <5

కొంతమందికి తర్కాన్ని అనుసరించడం కష్టంగా అనిపించవచ్చు. అందువల్ల, కొంతమంది ప్రోగ్రామర్లు రీడబిలిటీ కారణాల కోసం పునరావృత కుండలీకరణాలను జోడించడానికి ఇష్టపడతారు:

(age >= 7) && (height <5)

రిలేషనల్ ఆపరేటర్లు

ఈ ఆపరేటర్లు ఆపరేండ్ల మధ్య సాధారణ సంబంధాలను పోల్చడానికి ఉపయోగిస్తారు.

ఆపరేటర్	పేరు
>	అంతకన్నా ఎక్కువ
<	కంటే తక్కువ
> =	కంటే ఎక్కువ లేదా సమానం
<=	కంటే తక్కువ లేదా సమానం

రిలేషనల్ ఆపరేటర్‌లు అర్థం చేసుకోవడం చాలా సులభం, ఎందుకంటే అవన్నీ మీకు ఇప్పటికే తెలిసిన సాధారణ బీజగణిత ఆపరేటర్ల మాదిరిగానే ఉంటాయి. చెప్పటడానికి, > మరియు < పై పట్టికలో ఇవ్వబడిన అదే అర్థాన్ని మీకు ఇప్పటికే తెలుసు.

if( x <= 7 ){
x++;
}

పైవి ఉంటే స్టేట్మెంట్ x 7 కంటే తక్కువ లేదా సమానం కాదా అని తనిఖీ చేస్తుంది, ఒకవేళ నిజమైతే, బ్రాకెట్స్ లోపల స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి, లేకపోతే అవి చేయవు.

ఇప్పుడు సమానత్వ ఆపరేటర్లను పేర్కొనడానికి ఇది మంచి సమయం. వాటిలో కేవలం రెండు మాత్రమే (సమానం, == మరియు! =, సమానం కాదు). వారి పేరు సూచించినట్లుగా, వారు రెండు ఆపరేండ్ల మధ్య సమానత్వాన్ని పరీక్షించడానికి ఉపయోగిస్తారు.

సంబంధిత: జావాలో శ్రేణులపై ఆపరేషన్‌లను ఎలా సృష్టించాలి మరియు నిర్వహించాలి

ఈక్వాలిటీ ఆపరేటర్ (==) అసైన్‌మెంట్ ఆపరేటర్ (=) తో గందరగోళం చెందకూడదు. బిగినర్స్ ప్రోగ్రామర్లు రెండింటిని కలపడానికి ఇష్టపడతారు. ఇది సమంజసమైనది ఎందుకంటే బీజగణితంలో (=) చిహ్నం సమానత్వాన్ని వ్యక్తీకరించడానికి ఉపయోగించబడుతుంది. ప్రోగ్రామింగ్‌లో అది సరైనది కాదు.

అసైన్‌మెంట్ ఆపరేటర్ (=) వేరియబుల్‌కు ఒక విలువను కేటాయిస్తుంది, అయితే సమానత్వం ఆపరేటర్ (==) సమానత్వం కోసం పరీక్షిస్తారు. వ్యత్యాసాన్ని అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను చూడండి:

if(x=5){
// statements
}

పైన పేర్కొన్న కోడ్ x నిజానికి 5 కి సమానంగా ఉందా అనే దానితో సంబంధం లేకుండా ఎల్లప్పుడూ అమలు చేయబడుతుంది. ఇంతలో, దిగువ కోడ్ x 5 కి సమానమైతే మాత్రమే అమలు చేయబడుతుంది. అందువల్ల, రెండింటినీ కలపకపోవడం ముఖ్యం.

if(x==5){
// statements
}

రిలేషనల్ ఆపరేటర్ల కంటే తక్కువగా ఉన్నప్పటికీ, పేర్కొన్న ఇద్దరు సమానత్వ ఆపరేటర్లకు ఒకే స్థాయి ప్రాధాన్యత ఉంది.

రిలేషనల్ ఆపరేటర్లకు కూడా అదే స్థాయి ప్రాధాన్యత ఉంటుంది. ఈ ఆపరేటర్ల అమలు ఎడమ నుండి కుడికి మొదలవుతుంది.

జావా ఆపరేటర్ల యొక్క తదుపరి పరిశీలనలు

కొన్ని ఆపరేటర్‌లకు మరియు వారి ఆపరేండ్‌లకు మధ్య కొన్ని ఉదాహరణలలో వైట్‌స్పేస్ ఉందని మీరు గమనించాలి, మరికొన్నింటిలో అది లేదు.

ఆ స్థలం లేకపోవడం/ఉనికి మిమ్మల్ని చింతించకూడదు. కంపైలర్ దానిని విస్మరిస్తుంది. అందువల్ల, ఈ క్రింది వ్యక్తీకరణలు ఒకే విషయాన్ని సూచిస్తాయి:

Y>=7 // no whitespace
Y >= 7 // with whitespace

రిలేషనల్ ఆపరేటర్లు సాధారణంగా సాధారణ పరిస్థితులను వ్యక్తీకరించడానికి ఉపయోగిస్తారు. సాధారణ పరిస్థితులను మరింత సంక్లిష్టంగా కలపడానికి, మీరు లాజికల్ ఆపరేటర్‌లను ఉపయోగించాల్సి ఉంటుంది. లాజికల్ ఆపరేటర్లు బహుళ పరిస్థితులను పరీక్షించవచ్చు, రిలేషనల్ ఆపరేటర్లు కాకుండా కేవలం ఒక షరతును పరీక్షిస్తారు.

లాజికల్ ఆపరేటర్లు (|, &, ^) వారు సమగ్ర ఆపరేండ్‌లను కలిగి ఉన్నప్పుడు బిట్‌వైస్ ఆపరేటర్‌లుగా ఉండవచ్చని గమనించడం కూడా ముఖ్యం. బిట్‌వైస్ ఆపరేటర్‌లుగా ఉపయోగించినప్పుడు, వారు తమ ఒపెరాండ్‌ల బిట్‌లపై పనిచేస్తారు.

ఆపరేటర్‌ల యొక్క ఈ పరిజ్ఞానంతో, మీరు ఇప్పుడు జావా క్లాసులు నేర్చుకోవడానికి సన్నద్ధం కావాలి.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ జావాలో తరగతులను ఎలా సృష్టించాలో తెలుసుకోండి

మీరు జావాలో ప్రోగ్రామ్ చేయడం నేర్చుకుంటే, తరగతులను ఎలా సృష్టించాలో మీరు తెలుసుకోవాలి.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావా
• కోడింగ్ ట్యుటోరియల్స్

రచయిత గురుంచి జెరోమ్ డేవిడ్సన్(22 కథనాలు ప్రచురించబడ్డాయి)

జెరోమ్ MakeUseOf లో స్టాఫ్ రైటర్. అతను ప్రోగ్రామింగ్ మరియు లైనక్స్ గురించి కథనాలను కవర్ చేస్తాడు. అతను క్రిప్టో iత్సాహికుడు మరియు క్రిప్టో పరిశ్రమపై ఎల్లప్పుడూ ట్యాబ్‌లను ఉంచుతాడు.

జెరోమ్ డేవిడ్సన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి