"నమస్కారాలు, అమిగో! లాజిక్ సమస్యలను పరిష్కరించడం ద్వారా నేను చాలా దూరంగా ఉన్నాను, మీరు లోపలికి రావడం నేను గమనించలేదు. ఇదిగో మీ కోసం: మొసళ్ళు ఎగిరితే, మంచు తెల్లగా ఉంటుంది. అక్కడ ఎగిరే మొసలి ఉంది. ఏ తీర్మానం?"

"అమ్మో... ఐతే మనం మంచు తెల్లగా ఉందని నిర్ధారించుకున్నామా?"

"అద్భుతం! మీరు దీక్షా పరీక్షలో ఉత్తీర్ణులయ్యారు. మీరు తదుపరి టాపిక్‌లో ప్రావీణ్యం సంపాదించడానికి సిద్ధంగా ఉన్నారు. దీనిని 'లాజికల్ ఆపరేటర్లు' అంటారు. మరియు మేము బూలియన్ లాజిక్‌తో ప్రారంభిస్తాము. సహజంగానే, మీకు ఇది ఇప్పటికే తెలుసు. మీరు రోబోట్, అన్నింటికంటే . మేము జావా భాషతో సరిపోలడానికి మీ సెట్టింగ్‌లను సర్దుబాటు చేయాలి."

"బూలియన్ లాజిక్? నాకు ఇటీవల బూలియన్ రకం గురించి చెప్పబడింది..."

"అవును, ఇక్కడ ప్రత్యక్ష సంబంధం ఉంది. బూలియన్ వ్యక్తీకరణలు నిజం లేదా తప్పు మాత్రమే కావచ్చు. మరియు ఇది జరిగినప్పుడు, ఈ విధమైన తర్కం అనేది నిజం లేదా తప్పు అనే వ్యక్తీకరణలు మరియు అటువంటి వ్యక్తీకరణల కలయికల గురించి ఉంటుంది. ఉదాహరణకు, వ్యక్తీకరణ 18 < 25 ఎల్లప్పుడూ నిజం మరియు 7 < 5 ఎల్లప్పుడూ తప్పు. వ్యక్తీకరణ (i <10) i విలువపై ఆధారపడి ఉంటుంది. మరియు వ్యక్తీకరణ మూల్యాంకనం చేస్తే, ఉదాహరణకు, నిజం, అప్పుడు మనం ఏదైనా చేయమని ప్రోగ్రామ్‌ని అడగవచ్చు."

"ఆహ్, నాకు అర్థమైంది. బూలియన్ వ్యక్తీకరణలు తార్కిక ముగింపులు చేయడానికి మాత్రమే కాకుండా, ప్రోగ్రామ్‌లలో ఫోర్క్‌లను సృష్టించడానికి కూడా అనుమతిస్తాయి."

Java university

"సరిగ్గా. వాటిని ఎలా వ్రాయాలో నేర్చుకోవడం ప్రధాన విషయం. ఉదాహరణకు, జావాలో మీరు వెళ్లి వ్యక్తీకరణను వ్రాయలేరు 18 < age <65. ఇది వాక్యనిర్మాణం తప్పుగా ఉంటుంది మరియు ప్రోగ్రామ్ కంపైల్ చేయదు.

"కానీ మీరు దీన్ని ఇలా వ్రాయవచ్చు:

(18 < age) AND (age < 65)

వాస్తవానికి, మేము ఆంగ్ల పదాన్ని ఉపయోగించము AND. బదులుగా, మీకు బూలియన్ ఆపరేటర్ అవసరం . అంటే, 'AND' విభిన్నంగా సూచించబడుతుంది.

"జావాలో ముగ్గురు లాజికల్ ఆపరేటర్లు ఉన్నారు: AND(&&), OR(||), NOT(!).

శుభవార్త ఏమిటంటే, మీరు ఏదైనా సంక్లిష్టత యొక్క తార్కిక వ్యక్తీకరణలను రూపొందించడానికి కుండలీకరణాలను ఉపయోగించవచ్చు.

చెడ్డ వార్త ఏమిటంటే , జావా డెవలపర్లు పదాలకు బదులుగా సి భాష నుండి సంజ్ఞామానాన్ని ఉపయోగించాలని నిర్ణయించుకున్నారు andమరియు or.not

స్క్రీన్ వైపు చూడండి:

లాజికల్ ఆపరేటర్ నిరీక్షణ వాస్తవికత
AND (∧) and &&
OR (∨) or ||
NOT (¬) not !

"ఇది నిజానికి అంత చెడ్డది కాదు... ప్రెట్టీ కాంపాక్ట్. నేను వాటిని దాదాపుగా కంఠస్థం చేసాను."

"సరే, ఇది అద్భుతం. జావాలో లాజికల్ ఆపరేటర్‌లను ఉపయోగించేందుకు ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:

వ్యక్తీకరణ వివరణ వివరణ
(0 < a) && (a < 100) (0 < a) and (a < 100) (0 < a) AND (a < 100)
(!a) && (!b) (not a) and (not b) (NOT a) AND (NOT b)
!(!a || !b) not((not a) or (not b)) NOT((NOT a) OR (NOT b))

పోలిక ఆపరేటర్లు మరియు బూలియన్ వేరియబుల్స్ ఉపయోగించి ఉదాహరణలు

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

"అది ఎలా ఉంది?"

"మీరు లాజికల్ ఎక్స్‌ప్రెషన్‌లను వివిధ మార్గాల్లో వ్రాయవచ్చని నా ఉద్దేశ్యం. ఉదాహరణకు:

కోడ్ వివరణ 
int age = 35;
if (age >= 18 && age <= 65)
   System.out.println("You can work");
 వయస్సు విలువ 18మరియు మధ్య ఉంటే 65, "మీరు పని చేయవచ్చు" అనే పదబంధం ప్రదర్శించబడుతుంది. 
int age = 35;
boolean isYoung = (age < 18);
if (!isYoung && age <= 65)
   System.out.println("You can work");
 మేము isYoungవేరియబుల్‌ను సృష్టించాము మరియు వ్యక్తీకరణ యొక్క మొదటి భాగాన్ని దానిలోకి తరలించాము. మేము కేవలం age >= 18తో భర్తీ చేసాము age < 18. 
int age = 35;
boolean isYoung = (age < 18);
boolean isOld = (age > 65);
if (!isYoung && !isOld)
   System.out.println("You can work");
 మేము isOld వేరియబుల్‌ని సృష్టించాము మరియు వ్యక్తీకరణ యొక్క రెండవ భాగాన్ని దానిలోకి తరలించాము. అదనంగా, age <= 65ద్వారా భర్తీ చేయబడింది age > 65.

"ఈ మూడు ఉదాహరణలు సమానమైనవి. రెండవ ఉదాహరణలో మాత్రమే మేము వ్యక్తీకరణ యొక్క భాగాన్ని స్టేట్‌మెంట్ నుండి ifప్రత్యేక బూలియన్ వేరియబుల్ ( isYoung)కి తరలించాము. మూడవ ఉదాహరణలో, మేము వ్యక్తీకరణ యొక్క రెండవ భాగాన్ని రెండవ వేరియబుల్ ( isOld) లోకి తరలించాము. మార్గం ద్వారా, బూలియన్ వేరియబుల్ యొక్క డిఫాల్ట్ విలువ false."

"నేను దానిని గుర్తుంచుకుంటాను. నేను ఆశిస్తున్నాను."

తార్కిక అంకగణితం

"ఇప్పుడు మనం క్లుప్తంగా తార్కిక కార్యకలాపాల ద్వారా వెళ్దాం. అవి చాలా సరళమైన మరియు తార్కిక (లేకపోతే ఎలా కావచ్చు!) నియమాలను పాటిస్తాయి.

"మొదట , ఆపరేటర్ ఎలా పనిచేస్తుందో చూద్దాం OR. దీనిని డిస్జంక్షన్ అని కూడా ||అంటారు .

వ్యక్తీకరణ ఫలితం
true || true true
true || false true
false || true true
false || false false

a || b" టేబుల్ ఆధారంగా వ్యక్తీకరణ యొక్క ఫలితం ఏమిటో మీరు ఇప్పుడు అంచనా వేయగలరా ?"

"అలాగా!" trueవ్యక్తీకరణలో కనీసం ఒక పదం ఉంటే వ్యక్తీకరణ యొక్క విలువ true. రెండూ ఉంటే falseఫలితం ఉంటుంది false.

"అది కరెక్ట్. నువ్వు చాలా తెలివైనవాడివి కాబట్టి, టేబుల్‌ని మరోసారి చూసి, అది false0 మరియు true1 అని ఊహించుకోండి. మీరు దానిని ఆ విధంగా చూసినప్పుడు, ||ఆపరేటర్ ప్రవర్తన మీకు సాధారణ అంకగణితం నుండి ఏదైనా గుర్తుకు తెస్తుందా?"

"అమ్మో.. ఇది కాస్త కూడిక లాంటిదే... కానీ మీరు కూడిక చేసినప్పుడు 1 + 1 1కి సమానం కాదు."

||"మేము 0 మరియు 1 లతో మాత్రమే పని చేస్తే అది సమానం అనే భావన ఉంది. కానీ ఇప్పుడు దానితో బాధపడకండి. ముఖ్యమైన విషయం ఏమిటంటే మీరు ఆపరేషన్ మరియు జోడింపు మధ్య సారూప్యతను గమనించారు. దీని అర్థం మీరు గెలిచారు' ఈ ఆపరేషన్ తరచుగా 'తార్కిక జోడింపు' అని పిలువబడే వాస్తవం చూసి ఆశ్చర్యపోకండి.

"దొరికింది."

"ఇప్పుడు AND, aka &&, aka , aka జంక్షన్ ఆపరేటర్ , వేదికపైకి వచ్చారు.

వ్యక్తీకరణ ఫలితం
true && true true
true && false false
false && true false
false && false false

"నేను అర్థం చేసుకున్నట్లుగా, వ్యక్తీకరణ యొక్క ఫలితం trueవ్యక్తీకరణను రూపొందించే రెండు విలువలు ఉంటేనే ఉంటుంది true. లేకపోతే, అది ఎల్లప్పుడూ ఉంటుంది false."

"బాగా చేసారు, అమిగో! మీరు ఇదంతా స్పాంజిలాగా గ్రహిస్తున్నారు. మీరు అంకగణితంతో మరొక సారూప్యతను చూస్తున్నారా?"

"గుణకారం!"

"సరిగ్గా. కాబట్టి ఇక్కడ మనకు 'లాజికల్ గుణకారం' ఉంది".

"తర్వాత మనం ఆపరేటర్‌ను చూస్తాము NOT, అకా !, లాజికల్ ఇన్వర్స్ .

వ్యక్తీకరణ ఫలితం
!true false
!false true

"సరే, ఇక్కడ ప్రతిదీ చాలా సులభం. ఆపరేటర్ మారతారు trueమరియు falseదీనికి విరుద్ధంగా ఉంటుంది."

"సరిగ్గా. మీ కోసం ఇక్కడ కొన్ని ఉపయోగకరమైన వ్యక్తీకరణలు ఉన్నాయి:"

వ్యక్తీకరణ ఫలితం
m && !m false
m || !m true
!(a && b) !a || !b
!(a || b) !a && !b