వివిధ ఆపరేటర్లతో పని చేసే సూక్ష్మ నైపుణ్యాలు

1. బూలియన్ కార్యకలాపాలు

|మరియు ఆపరేటర్లు &సంఖ్యలకు మాత్రమే కాకుండా, బూలియన్ వ్యక్తీకరణలకు కూడా వర్తించవచ్చు.

కానీ, మీకు ఇప్పటికే తెలిసినట్లుగా, ఆపరేటర్లు &&ఉన్నారు ||. |మేము బదులుగా ||మరియు &బదులుగా ఎందుకు ఉపయోగిస్తాము &&? ఇందులో ఏమైనా ప్రయోజనం ఉందా? ఉన్నట్లు తెలుస్తోంది. కొన్నిసార్లు.

మరియు లాజికల్ ఆపరేటర్‌లు సోమరి సూత్రం అని పిలవబడే విధానాన్ని అనుసరించి ఎడమ నుండి కుడికి అమలు ||చేయబడతారు .&&

(expression1) || (expression2) || (expression3)

expression1 కు సమానంగా ఉంటే true, మూల్యాంకనం చేయడంలో ఎటువంటి ప్రయోజనం ఉండదు expression2 మరియు expression3: ఫలితంతో trueసంబంధం లేకుండా ఉంటుంది.

దీని ప్రకారం, వ్యక్తీకరణలను మూల్యాంకనం చేసేటప్పుడు (అవి ఎడమ నుండి కుడికి మూల్యాంకనం చేయబడతాయి), మనకు వచ్చిన వెంటనే true, మిగిలిన వ్యక్తీకరణల మూల్యాంకనం దాటవేయబడుతుంది . మరియు పద్ధతి కాల్‌లను చేర్చినట్లయితే, expression2 ఈ పద్ధతులు కాల్ చేయబడవు !expression3

లాజికల్ ఆపరేటర్‌కి కూడా ఇదే వర్తిస్తుంది &&:

(expression1) && (expression2) && (expression3)

expression1కు సమానంగా ఉంటే false, మూల్యాంకనం చేయడంలో ఎటువంటి ప్రయోజనం ఉండదు expression2మరియు expression3: ఫలితంతో falseసంబంధం లేకుండా ఉంటుంది.

ఇది మీరు వంటి విషయాలను వ్రాయడానికి అనుమతించే ముఖ్యమైన వాస్తవం:

String s = null;
if (s != null && s.length() > 0) {

పై ఉదాహరణ మీకు ఎప్పటికీ NullPointerException ని పొందదు , ఎందుకంటే s.length()మొదటి భాగం అయితే మాత్రమే అమలు s! = nullచేయబడుతుంది true.

sకు సమానంగా ఉంటే , ఆపరేటర్ nullయొక్క ఎడమ వైపు భాగం , అప్పుడు మొత్తం బూలియన్ వ్యక్తీకరణ యొక్క ఫలితం , కాబట్టి కుడి వైపు ( ) భాగం మూల్యాంకనం చేయబడదు.&&falsefalses.length() > 0

2. జావాలో ఆపరేషన్ ప్రాధాన్యత

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

జావాలో ఆపరేటర్లు కూడా ప్రాధాన్యత క్రమాన్ని కలిగి ఉన్నారు. వ్యత్యాసం ఏమిటంటే, ఎ) వాటిలో కొంచెం ఎక్కువ ఉన్నాయి, బి) కొంతమంది ఆపరేటర్లకు, ఒపెరాండ్‌లు ఎడమ నుండి కుడికి, ఇతరులకు - కుడి నుండి ఎడమకు మూల్యాంకనం చేయబడతాయి.

అన్ని జావా ఆపరేటర్లతో కూడిన పట్టిక ఇక్కడ ఉంది:

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

ఆపరేటర్లు పట్టికలో తక్కువగా ఉంటే, వారి ప్రాధాన్యత తక్కువగా ఉంటుంది.

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

జావాలో, మీరు వంటిది వ్రాయవచ్చు if (a & 1<< b > ~c), కానీ మీరు వ్రాయకూడదు. మీరు కంపైలర్ కోసం మాత్రమే కాకుండా ఇతర ప్రోగ్రామర్‌ల కోసం కూడా కోడ్‌ని వ్రాస్తున్నారు. కోడ్ ఎంత ఎక్కువ చదవగలిగితే అంత మంచిది.

3. ఉపసర్గ మరియు పోస్ట్‌ఫిక్స్ ఇంక్రిమెంట్

మీకు ఇప్పటికే తెలిసినట్లుగా, జావాలో ఇంక్రిమెంట్ ఆపరేటర్ ( ++) మరియు డిక్రిమెంట్ ఆపరేటర్ ( --) ఉన్నాయి. వరుసగా, అవి వేరియబుల్ విలువను పెంచుతాయి మరియు తగ్గిస్తాయి 1.

ఈ ఆపరేటర్లలో రెండు రకాలు ఉన్నాయని మీకు బహుశా తెలియదు: ఉపసర్గ (ఆపరేటర్ వేరియబుల్ ముందు ఉంచబడుతుంది) మరియు పోస్ట్‌ఫిక్స్ (ఆపరేటర్ వేరియబుల్ తర్వాత ఉంచబడుతుంది). మరియు రెండు రకాల ఆపరేటర్లు కొద్దిగా భిన్నంగా పని చేస్తారు.

జావాలో, మీరు ఇలాంటి వ్యక్తీకరణను వ్రాయవచ్చు:

int a = 5;
int b = a++;

ఒక వేరియబుల్ తర్వాత ఆపరేటర్ ++కనిపించినట్లయితే మరియు వేరియబుల్ కొంత వ్యక్తీకరణలో భాగమైతే (పై ఉదాహరణలో వలె), అప్పుడు వ్యక్తీకరణ వేరియబుల్ యొక్క ప్రస్తుత విలువను ఉపయోగిస్తుంది మరియు ఆ తర్వాత మాత్రమే వేరియబుల్ ద్వారా పెరుగుతుంది 1.

మరో మాటలో చెప్పాలంటే, ఇలాంటిదే జరుగుతుంది:

int a = 5;
int b = a;
a = a + 1;

అంటే, bఉంటుంది 5, 6మీరు మొదటి చూపులో ఆలోచించినట్లు కాదు.

ఆపరేటర్ వేరియబుల్‌కు ముందు ఉంటే ++మరియు వేరియబుల్ కొంత వ్యక్తీకరణలో భాగమైతే, అది మొదట పెంచబడుతుంది 1మరియు ఆ తర్వాత మాత్రమే వ్యక్తీకరణలో దాని విలువ ఉపయోగించబడుతుంది.

int a = 5;
int b = ++a;

int a = 5;
a = a + 1;
int b = a;

ఇక్కడ, bసమానంగా ఉంటుంది 6.

జావా ప్రోగ్రామర్లు ఎవరైనా జావా ప్రోగ్రామర్ కాదా అని నిర్ధారించడానికి జావా ప్రోగ్రామర్లు ఉపయోగించే ఒక ఉదాహరణ కూడా ఉంది:

int a = 5;
int b = ++a + ++a;

అవును, మీరు కూడా వ్రాయవచ్చు.

ఈ ఉదాహరణ బాగా కంపైల్ చేస్తుంది మరియు ఇలా మారుతుంది:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

ఆపరేటర్ కోసం --, ప్రతిదీ సరిగ్గా అదే.