- ఈ రకమైన బూలియన్ ఆదిమ రకం లేదా బూలియన్ వేరియబుల్
- జావా బూలియన్ క్లాస్ లేదా బూలియన్ రేపర్ వస్తువు
- బూలియన్ వ్యక్తీకరణ, బూలియన్ విలువ, కొంత షరతు
- జావా బూలియన్ ఆపరేటర్లు
సాధారణ అర్థంలో బూలియన్ అంటే ఏమిటి
బూలియన్ వ్యక్తీకరణ యొక్క భావన గణితం నుండి వచ్చింది, లేదా గణిత తర్కం నుండి వచ్చింది. ప్రతిపాదిత బీజగణితంలో బూలియన్ వ్యక్తీకరణ అనేది నిజం లేదా తప్పు అని చెప్పగలిగే వ్యక్తీకరణ. ఉదాహరణకి:
“మంచు తెల్లగా ఉంది” “మొసళ్ళు ఎగరగలవు” “2 + 2 = 4” “1 + 1 = 21”
అదే సమయంలో, "2" లేదా "మంచు" బూలియన్ వ్యక్తీకరణలు కాదు.
జావా బూలియన్ ఆదిమ డేటా రకం మరియు బూలియన్ వేరియబుల్స్
జావాలో బూలియన్ గురించి మాట్లాడితే, మొదట ఇది బూలియన్ ఆదిమ డేటా రకం మరియు ఈ రకమైన బూలియన్ వేరియబుల్స్. మీరు బహుశా ఇప్పటికే ఊహించినట్లుగా, ఈ రకమైన వేరియబుల్స్ నిజమైన మరియు తప్పు అనే రెండు విలువలను మాత్రమే తీసుకోగలవు. జావా చాలా కఠినమైన పరిమితులను కలిగి ఉంది: జావాలోని బూలియన్ ఏ ఇతర డేటా రకానికి మార్చబడదు మరియు వైస్ వెర్సా. ప్రత్యేకించి, జావాలోని బూలియన్ ఒక సమగ్ర రకం కాదు మరియు బూలియన్‌లకు బదులుగా పూర్ణాంక విలువలు ఉపయోగించబడవు. బూలియన్ రకాన్ని నేరుగా సెట్ చేయడానికి ఇక్కడ ఒక ఉదాహరణ :boolean myBoolean; //boolean variable
myBoolean = false;
boolean myBoolean1 = true; //another boolean variable//boolean variable example
public class BoolTest {
public static void main(String[] args) {
boolean myBoolean = false;
System.out.println(myBoolean);
}
}జావాలో బూలియన్ వ్యక్తీకరణలు
బూలియన్ వేరియబుల్‌ను ట్రూ లేదా ఫాల్స్‌కు స్పష్టంగా ప్రారంభించడంతో పాటు , బూలియన్ డేటా రకం చాలా చోట్ల పరోక్షంగా ఉపయోగించబడుతుంది. సంఖ్యల జోడింపు ఫలితం సంఖ్య అయినట్లే, ఏదైనా పోలిక యొక్క ఫలితం నిజం లేదా తప్పుగా ఉంటుంది, అంటే అది బూలియన్ రకంగా ఉంటుంది . దీనర్థం, బూలియన్ వేరియబుల్ అసైన్‌మెంట్ స్టేట్‌మెంట్ ద్వారా నేరుగా బూలియన్ విలువను పేర్కొనడంతో పాటు , బూలియన్ విలువలు 5 > 2 వంటి వివిధ పోలికల నుండి ఉత్పన్నమవుతాయి మరియు ప్రాథమికంగా షరతులతో కూడిన మరియు లూప్ స్టేట్‌మెంట్‌లలో ఉపయోగించబడతాయి. బూలియన్ రకం యొక్క అటువంటి ఉపయోగం యొక్క ఉదాహరణ ఇక్కడ ఉంది :public class BoolTest {
public static void main(String[] args) {
boolean myBoolean = false;
int a = 5;
int b = 7;
System.out.println(a < b);
System.out.println(0 > 7);
System.out.println(myBoolean == false);
}
}
నిజం తప్పు నిజం
ఒక <b విషయంలో , < ఆపరేటర్ ఎడమ వైపున ఉన్న వ్యక్తీకరణను కుడి వైపున ఉన్న వ్యక్తీకరణతో పోల్చారు. మేము స్క్రీన్‌పై పోలిక ఫలితాన్ని ప్రదర్శించాము. 5 < 7 (స్టేట్‌మెంట్ నిజం) నుండి కన్సోల్‌కు నిజమైన విలువ ముద్రించబడుతుంది. రెండవ సందర్భంలో, మేము సున్నా మరియు ఏడు యొక్క ప్రత్యక్ష పోలికను ప్రదర్శిస్తాము మరియు మూడవది, వేరియబుల్ myBoolean విలువ తప్పు కాదా అని అడుగుతాము. ఇది సందర్భం కాబట్టి, మేము విలువను నిజమైన అవుట్‌పుట్ చేస్తాము . నిజానికి, జావాలో బూలియన్ ఎక్స్‌ప్రెషన్‌లను రూపొందించడానికి, మనం ఏదైనా పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు:
| పోలిక ఆపరేటర్లు | జావా ఆపరేటర్ | ఆపరేషన్ ఉదాహరణ | ఆపరేషన్ ఫలితం |
|---|---|---|---|
| తక్కువ | < | ఎ < బి | a b కంటే తక్కువగా ఉంటే నిజం లేకపోతే తప్పు |
| గ్రేటర్ | > | a > b | a b కంటే ఎక్కువ అయితే నిజం , లేకపోతే తప్పు |
| కంటే తక్కువ లేదా సమానం | <= | ఒక <= బి | a b కంటే తక్కువగా ఉంటే లేదా అవి సమానంగా ఉంటే నిజం , లేకపోతే తప్పు |
| ఎక్కువ లేదా సమానం | >= | a >= బి | నిజం , ఒకవేళ b కి ఎక్కువ లేదా సమానం అయితే , తప్పు |
| సమానం | == | a == b | నిజం , ఒకవేళ a b కి సమానం అయితే , తప్పు |
| సమానము కాదు | != | a != b | నిజం , ఒకవేళ b కి సమానం కాకపోతే , తప్పు |
ఇక్కడ బూలియన్ విలువలు ఉపయోగించబడతాయి
బూలియన్ విలువలు మరియు షరతులతో కూడిన వ్యక్తీకరణలు చాలా తరచుగా బ్రాంచ్ స్టేట్‌మెంట్‌లు, టెర్నరీ ఆపరేటర్లు మరియు లూప్‌ల పరిస్థితులలో ఉపయోగించబడతాయి. వాస్తవానికి, వాటి ఉపయోగం నిర్దిష్ట బూలియన్ వ్యక్తీకరణలను తనిఖీ చేయడంపై ఆధారపడి ఉంటుంది. ఉదాహరణకి:public class BoolTest2 {
public static void main(String[] args) {
int i = 0;
while (i <= 10)
{
System.out.println(i);
i++;
}
}
}
జావా బూలియన్ ఆపరేటర్లు. బూలియన్ ఆపరేటర్లతో బూలియన్ వ్యక్తీకరణలను రూపొందించడం
కింది తార్కిక (లేదా బూలియన్) కార్యకలాపాలు జావాలో అందుబాటులో ఉన్నాయి:-
తార్కిక నిరాకరణ, ఇది కూడా కాదు లేదా విలోమం. జావాలో, గుర్తుతో సూచించబడుతుంది ! వ్యక్తీకరణకు ముందు.
-
లాజికల్ మరియు, ఇది కూడా AND లేదా సంయోగం. ఇది వర్తింపజేయబడిన రెండు వ్యక్తీకరణల మధ్య & చిహ్నం ద్వారా సూచించబడుతుంది .
-
లాజికల్ లేదా జావాలో, ఇది కూడా OR, ఇది డిస్జంక్షన్ కూడా. జావాలో, గుర్తుచే సూచించబడుతుంది | రెండు వ్యక్తీకరణల మధ్య.
-
ప్రత్యేకమైన లేదా, XOR, కఠినమైన డిస్జంక్షన్. జావాలో, ఇది రెండు వ్యక్తీకరణల మధ్య చిహ్నం ^ ద్వారా సూచించబడుతుంది.
-
జావాలో, లాజికల్ ఆపరేటర్లు షరతులతో కూడిన లేదా, || , అలాగే షరతులతో కూడిన మరియు, && .
a | b == true| బూలియన్ జావా ఆపరేటర్ | పేరు | టైప్ చేయండి | వివరణ | ఉదాహరణ |
|---|---|---|---|---|
| ! | తార్కిక “కాదు” (నిరాకరణ) | అపరిమితమైన | !x అంటే "x కాదు". x తప్పు అయితే ఒప్పు అని చూపుతుంది . x నిజమైతే తప్పు అని చూపుతుంది . _ |
అప్పుడు |
| & | తార్కిక "మరియు" (మరియు, తార్కిక గుణకారం) | బైనరీ | (a & b) a మరియు b రెండూ నిజమైతే నిజాన్ని అందిస్తుంది . |
అప్పుడు |
| | | లాజికల్ OR (తార్కిక జోడింపు) | బైనరీ | (a | b ) a లేదా b లేదా రెండూ నిజమైతే నిజాన్ని చూపుతుంది |
అప్పుడు |
| ^ | లాజికల్ ఎక్స్‌క్లూజివ్ OR (XOR) | బైనరీ | (a ^ b) ఒపెరాండ్‌లలో ఒకటి (a లేదా b) మాత్రమే నిజమైతే నిజం . a మరియు b రెండూ ఏకకాలంలో ఒప్పు లేదా తప్పు అయితే తప్పు అని చూపుతుంది . నిజానికి a b కి సమానం కానట్లయితే అది నిజమని చూపుతుంది . |
అప్పుడు |
| && | షరతులతో కూడిన AND (సంక్షిప్త లాజికల్ AND) | బైనరీ | a && b ఇది a & b లాగానే ఉంటుంది , కానీ a తప్పు అయితే , ఆపరేటర్ b ని తనిఖీ చేయకుండా తప్పుని తిరిగి పంపుతారు . | |
| || | షరతులతో కూడిన OR (సంక్షిప్త లాజికల్ OR) | బైనరీ | ఒక || b అంటే a | b , కానీ a ఒప్పు అయితే , ఆపరేటర్ b ని తనిఖీ చేయకుండానే కేవలం నిజమైనదిగా చూపుతుంది . |
public class BoolTest2 {
public static void main(String[] args) {
int a = 5;
int b = 7;
boolean myBool1 = true;
boolean myBool2 = false;
System.out.println(myBool1&myBool2);
System.out.println(myBool1|myBool2);
System.out.println(!myBool1);
System.out.println((a > b) & !myBool1 | myBool2);
}
}
తప్పుడు నిజం అబద్ధం
వాస్తవానికి, మీరు లాజికల్ ఆపరేటర్లను ఉపయోగించి చాలా క్లిష్టమైన తార్కిక నిర్మాణాలను చేయవచ్చు. ఉదాహరణకి
(a<!b)&(q+1 == 12)^(!a | c & b > 1 + b)|(q ^ a > !b)
అన్ని వేరియబుల్స్ ప్రారంభించబడితే, అటువంటి నిర్మాణాలు పని చేస్తాయి. అయితే, మీరు వాటిని దుర్వినియోగం చేయకూడదు, అవి కోడ్‌ను చదవడం కష్టతరం చేస్తాయి. అయినప్పటికీ, అటువంటి తార్కిక నిర్మాణాలతో వ్యవహరించడం చాలా ఉపయోగకరంగా ఉంటుంది. పట్టికలో ఇవ్వబడిన ఇతర తార్కిక ఆపరేటర్లతో తార్కిక వ్యక్తీకరణలను చేయడానికి ప్రయత్నించండి.
తార్కిక కార్యకలాపాల ప్రాధాన్యత
గణితశాస్త్రంలో వలె, ప్రోగ్రామింగ్‌లో, ఆపరేటర్లు ఒకే వ్యక్తీకరణలో సంభవించినట్లయితే నిర్దిష్ట అమలు క్రమాన్ని కలిగి ఉంటారు. యునరీ ఆపరేటర్లు బైనరీ వాటి కంటే ప్రయోజనాలను కలిగి ఉంటాయి మరియు అదనంగా కంటే గుణకారం (తార్కికంగా కూడా) ఉంటాయి. టాపిక్‌ల లిస్ట్‌లో లాజికల్ ఆపరేటర్లు ఎక్కువగా ఉన్నారు, వారి ప్రాధాన్యత ఎక్కువ:-
!
-
&
-
^
-
|
-
&&
-
||
జావా బూలియన్ రేపర్
జావాలో, ప్రతి ఆదిమ రకానికి "సోదరుడు", ఒక రేపర్ క్లాస్ ( ర్యాపర్ ) ఉంటుంది. రేపర్ అనేది ఒక ప్రత్యేక తరగతి, ఇది లోపల ఆదిమ విలువను నిల్వ చేస్తుంది. అయితే ఇది ఒక తరగతి, కాబట్టి మీరు దాని యొక్క ఉదాహరణలను (వస్తువులు) సృష్టించవచ్చు. ఈ ఆబ్జెక్ట్‌లు ఆదిమానవుల అవసరమైన విలువలను లోపల నిల్వ చేస్తాయి, అయితే అవి నిజమైన వస్తువులు. జావా బూలియన్ ఆదిమ రకం రేపర్ జావా బూలియన్ (మూలధనం Bతో) తరగతిని కలిగి ఉంది. బూలియన్ క్లాస్ వస్తువులు ఇతర వాటిలాగే సృష్టించబడతాయి:Boolean b = new Boolean(false);పార్స్‌బూలియన్ పద్ధతి ఉదాహరణ
public class BoolTest2 {
public static void main(String[] args)
{
System.out.println(Boolean.parseBoolean("True"));
System.out.println(Boolean.parseBoolean("TRuE"));
System.out.println(Boolean.parseBoolean("False"));
System.out.println(Boolean.parseBoolean("here"));
}
}
నిజం నిజం అబద్ధం
మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము
GO TO FULL VERSION