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

"హాయ్, అమిగో!"

"ఇప్పుడు మనకు లాజికల్ ఆపరేటర్లపై చిన్న పాఠం ఉంటుంది."

"మీకు ఏ లాజికల్ ఆపరేటర్లు తెలుసు?"

— లేదా (||), మరియు (&&), కాదు(!)

"అవును. మంచి పని. మరి అవి ఎలా పనిచేస్తాయో గుర్తుందా?"

"అవును."

"లేదా కనీసం ఒక ఒపెరాండ్ నిజం అయినప్పుడు నిజం అవుతుంది."

"మరియు రెండు ఒపెరాండ్‌లు నిజం అయినప్పుడు నిజమైన ఫలితం వస్తుంది."

"ఒప్పును తప్పుగా మార్చదు మరియు తప్పును నిజంగా మార్చదు."

"అది సరే. మరియు ఈ వ్యక్తీకరణలో ఆపరేటర్లు ఏ క్రమంలో మూల్యాంకనం చేయబడతారు?"

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = a && b || !c && b || !a;

"ఇదంతా చాలా సులభం."

"మొదట, కాదు (!), ఆపై AND (&&), ఆపై OR (||) చివరిలో."

మేము కుండలీకరణాలను జోడిస్తే, మనం పొందుతాము:

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = (a && b) || ((!c) && b) || (!a);

"అదంతా కరెక్ట్, బాగా చేసారు. మరి ఫలితం ఏమిటి?"

- 1) (a && b) == (నిజం && తప్పుడు) == తప్పు

2) ((!c) && b) == (తప్పుడు && తప్పుడు) == తప్పు

3) (!a) == తప్పు

4) తప్పుడు || తప్పుడు || తప్పుడు == తప్పుడు

"ఫలితం తప్పు."

"మీకు టాపిక్ పర్ఫెక్ట్ గా తెలిసినట్టుంది. అప్పుడు నేను మీకు రెండు చిన్న రహస్యాలు చెబుతాను."

"మొదట, తార్కిక వ్యక్తీకరణలు ఎడమ నుండి కుడికి మూల్యాంకనం చేయబడతాయి."

"రెండవది, షార్ట్-సర్క్యూట్ మూల్యాంకనం ఇక్కడ ఉపయోగించబడుతుంది (అవసరమైతే మాత్రమే గణనలు నిర్వహించబడతాయి). వ్యక్తీకరణ యొక్క భాగాన్ని మూల్యాంకనం చేయడం ద్వారా తుది ఫలితం ఇప్పటికే తెలిసి ఉంటే, మిగిలిన వ్యక్తీకరణ మూల్యాంకనం చేయబడదు."

boolean result = (true && false) || (true && true) || (true && false);

"ఈ వ్యక్తీకరణ OR (||) ఆపరేటర్ ద్వారా వేరు చేయబడిన మూడు భాగాలుగా విభజించబడింది."

"కనీసం ఒక భాగమైనా నిజం అయితే, సమాధానం నిజం మరియు మరేమీ పరిగణించాల్సిన అవసరం లేదు. తదనుగుణంగా, వ్యక్తీకరణ ఇలా మూల్యాంకనం చేయబడుతుంది:"

1)  మొదటి భాగాన్ని మూల్యాంకనం చేయండి:  (నిజం && తప్పుడు) == తప్పు

2)  రెండవ భాగాన్ని మూల్యాంకనం చేయండి:  (నిజం && నిజం) == నిజం

3) మేము మూడవ భాగాన్ని మూల్యాంకనం చేయము, ఎందుకంటే సమాధానం నిజమని ఇప్పటికే స్పష్టంగా ఉంది .

"ఈ విధానాన్ని సోమరితనం మూల్యాంకనం అని కూడా పిలుస్తారు."

"సరే. మరి ఇందులో విశేషం ఏమిటి?"

"ఏమీ లేదు-మీరు వ్యక్తీకరణ లోపల పద్ధతులను పిలవడం ప్రారంభించే వరకు. వ్యక్తీకరణలో కొంత భాగం దాటవేయబడితే, దాటవేయబడిన భాగంలోని పద్ధతులు పిలవబడవు."

"కానీ ఈ విధానం చాలా సాధారణమైంది. ఇక్కడ ఎందుకు ఉంది:"

Job job = null;

if (job != null && job.isDone())
{
…
}

"వ్యక్తీకరణ మూల్యాంకనం చేయబడినప్పుడు ఉద్యోగం శూన్యం అయితే, job.isDone() కాల్ జరగదు!"

"నిజానికి, వ్యక్తీకరణ యొక్క మొదటి భాగం తప్పు, దాని తర్వాత AND (&&). కాబట్టి, మొత్తం వ్యక్తీకరణ తప్పు అని తెలుస్తుంది మరియు రెండవ భాగం అవసరం లేదు."

"సరిగ్గా. ఇది మంచి టెక్నిక్, అవునా?"

"అవును."