1. Booleanరకం

మనం ఇప్పటికే చూసినట్లుగా, జావాలో సూపర్ ఉపయోగకరమైన if-elseప్రకటన ఉంది. కుండలీకరణాల్లోని షరతు నిజమైతే ఇది ఒక బ్లాక్ స్టేట్‌మెంట్‌లను మరియు కండిషన్ తప్పు అయితే రెండవ బ్లాక్ స్టేట్‌మెంట్‌లను అమలు చేస్తుంది.

నిజం లేదా తప్పు కావచ్చు వ్యక్తీకరణలతో పని చేస్తున్నప్పుడు సౌలభ్యం కోసం, జావా సృష్టికర్త ప్రత్యేక booleanరకాన్ని జోడించారు. దీని ప్రధాన లక్షణం ఏమిటంటే, ఈ రకమైన వేరియబుల్స్ కేవలం రెండు విలువలను మాత్రమే తీసుకోగలవు: trueమరియు false.

వేరియబుల్స్‌కు ఇతర విలువలను కేటాయించడం అసాధ్యం boolean. కంపైలర్ దానిని అనుమతించదు.

మరియు మనకు అలాంటి ఆదిమ రకం ఎందుకు అవసరం?

బాగా, మంచి విషయం ఏమిటంటే మీరు తార్కిక వ్యక్తీకరణల విలువలను నిల్వ చేయడానికి దీన్ని ఉపయోగించవచ్చు. ఉదాహరణ:

Java webinar
కోడ్ వివరణ 
boolean isOK = true;
 బూలియన్ isOKవేరియబుల్ విలువను కలిగి ఉంటుందిtrue 
boolean hasError = false;
 బూలియన్ hasErrorవేరియబుల్ విలువను కలిగి ఉంటుందిfalse 
int age = 70;
boolean isSenior = (age > 65);
 బూలియన్ isSeniorవేరియబుల్ విలువను కలిగి ఉంటుందిtrue 
int record = 612;
int value = 615;
boolean hasNewRecord = (value > record);
 బూలియన్ hasNewRecordవేరియబుల్ విలువను కలిగి ఉంటుందిtrue 
int min = 0;
int max = 100;
int temperature = -20;
boolean isIce = (temperature < min);
boolean isSteam = (temperature > max);

బూలియన్ isIceవేరియబుల్ విలువను కలిగి ఉంటుందిtrue

బూలియన్ isSteamవేరియబుల్ విలువను కలిగి ఉంటుందిfalse

2. బూలియన్ వేరియబుల్స్ ఉపయోగించడం

బూలియన్ వేరియబుల్స్ ఎక్స్‌ప్రెషన్‌ల ఫలితాలను మాత్రమే నిల్వ చేయగలిగితే అవి పెద్దగా ఉపయోగపడవు. ఇక్కడ విషయం ఏమిటంటే మీరు వాటిని కూడా ఉపయోగించవచ్చు. ఎక్కడ? మీరు ఎక్కడైనా లాజికల్ ఎక్స్‌ప్రెషన్‌ని వ్రాయవచ్చు.

ఉదాహరణకు, మీరు స్టేట్‌మెంట్ కండిషన్‌లో బూలియన్ వేరియబుల్‌ని ఉపయోగించవచ్చు if:

కోడ్ సమానమైనది 
int age = 70;
boolean isSenior = (age > 65);
if (isSenior)
   System.out.println("Time to retire");
 
int age = 70;
if (age > 65)
   System.out.println("Time to retire");

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

3. పోలిక ఆపరేటర్లు

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

ఆపరేటర్ వివరణ ఉదాహరణ
< కంటే తక్కువ a < 10
> అంతకన్నా ఎక్కువ b > a
<= కంటే తక్కువ లేదా సమానం a <= 10
>= కంటే ఎక్కువ లేదా సమానం speed >= max
== సమానం age == 18
!= సమానం కాదు time != 0

పై ఆపరేటర్లు లాజికల్ ఎక్స్‌ప్రెషన్‌లను ఉత్పత్తి చేయడానికి ఉపయోగించబడతాయి. ఫలితాలు వేరియబుల్స్‌లో నిల్వ చేయబడతాయి booleanలేదా స్టేట్‌మెంట్ యొక్క షరతుగా ఉపయోగించవచ్చు if.

ముఖ్యమైన పాయింట్ నం. 1:

రెండు అక్షరాలను కలిగి ఉన్న ఆపరేటర్‌లను వేరుగా విభజించడం సాధ్యం కాదు.

మరో మాటలో చెప్పాలంటే, ఇలాంటి కోడ్ కంపైల్ చేయదు:

a < = 10
speed > = max
age = = 18
time ! = 0
ముఖ్యమైన పాయింట్ నం. 2:

=>ఎవరూ లేదా =<ఆపరేటర్లు లేరని గమనించండి . <=మరియు ఆపరేటర్లు మాత్రమే >=. మీరు వ్రాస్తే , మీ కోడ్ కంపైల్ చేయబడదు.a=< 3

ముఖ్యమైన పాయింట్ నం. 3:

జావాలో, మీరు వంటి వ్యక్తీకరణను వ్రాయలేరు . అన్ని తరువాత, వ్యక్తీకరణ మూల్యాంకనం చేయబడుతుంది లేదా . మరియు మీరు పోలికను నిర్వహించలేరు (రకాలు భిన్నంగా ఉంటాయి). కనీసం జావాలో.18 < age < 6518 < agetruefalsetrue < 65

ఏమి చేయవచ్చు? మీరు ఈ ప్రశ్నకు సమాధానాన్ని తదుపరి పాఠంలో కనుగొంటారు.