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! = nulltrue

sच्या समान असल्यास , nullऑपरेटरच्या डावीकडील भाग &&आहे false, तर संपूर्ण बुलियन अभिव्यक्तीचा परिणाम आहे false, म्हणून उजवीकडील भाग ( s.length() > 0) चे मूल्यमापन केले जात नाही.

हे सर्व सांगायचे आहे:

जर तुम्ही |ऑपरेटर किंवा &ऑपरेटर वापरत असाल, तर कोणतेही आळशी मूल्यमापन होणार नाही : प्रत्येक उप-अभिव्यक्तीचे नेहमी मूल्यांकन केले जाईल.



2. Java मध्ये ऑपरेशनला प्राधान्य

तुमच्या हायस्कूलच्या गणिताच्या वर्गातून तुम्हाला कदाचित आठवत असेल की, बेरीज ऑपरेटरपेक्षा गुणाकार ऑपरेटरला जास्त प्राधान्य असते. कंसांना आणखी उच्च प्राधान्य आहे: कंसातील अभिव्यक्तींचे प्रथम मूल्यांकन केले जाते, नंतर गुणाकार आणि भागाकार आणि नंतर बेरीज आणि वजाबाकी.

Java मधील ऑपरेटरना देखील प्राधान्यक्रम आहे. फरक असा आहे की अ) त्यापैकी थोडे अधिक आहेत, ब) काही ऑपरेटरसाठी, ऑपरेंडचे मूल्यांकन डावीकडून उजवीकडे केले जाते, तर इतरांसाठी - उजवीकडून डावीकडे.

येथे सर्व Java ऑपरेटर्ससह एक टेबल आहे:

श्रेणी ऑपरेटर सहयोगी
पोस्टफिक्स () [] . डावीकडून उजवीकडे
युनरी ++ -- ! ~ उजवीकडून डावीकडे
गुणाकार * / % डावीकडून उजवीकडे
जोडणारा + - डावीकडून उजवीकडे
सरकत आहे >> >>> << डावीकडून उजवीकडे
संबंधीत > >= < <= डावीकडून उजवीकडे
समानता == != डावीकडून उजवीकडे
बिटवाइजAND & डावीकडून उजवीकडे
Exclusive OR(XOR) ^ डावीकडून उजवीकडे
बिटवाइजOR | डावीकडून उजवीकडे
तार्किकAND && डावीकडून उजवीकडे
तार्किकOR || डावीकडून उजवीकडे
सशर्त ?: उजवीकडून डावीकडे
असाइनमेंट = += -= *= /= %= >>= <<= &= ^= |= उजवीकडून डावीकडे
स्वल्पविराम , डावीकडून उजवीकडे

शीर्ष ओळीत सर्वोच्च प्राधान्य असलेले ऑपरेटर समाविष्ट आहेत. कंस ()स्पष्टपणे प्राधान्य सेट करण्यासाठी वापरले जातात. []अॅरे व्हेरिएबलच्या विशिष्ट इंडेक्समध्ये घटक ऍक्सेस करण्यासाठी स्क्वेअर ब्रॅकेटचा वापर केला जातो. .ऑब्जेक्ट किंवा क्लासचा संदर्भ वापरून फील्ड आणि पद्धतींमध्ये प्रवेश करण्यासाठी डॉट ऑपरेटर ( ) वापरला जातो.

टेबलमध्ये ऑपरेटर जितके कमी असतील तितके त्यांचे प्राधान्य कमी असेल.

तुम्ही अभिव्यक्तीमध्ये एकाधिक ऑपरेटर वापरत असल्यास, आळशी होऊ नका: कंस जोडा.

Java मध्ये, आपण असे काहीतरी लिहू शकता if (a & 1<< b > ~c), परंतु आपण तसे करू नये. तुम्ही केवळ कंपाइलरसाठीच नाही तर इतर प्रोग्रामरसाठीही कोड लिहित आहात. कोड जितका वाचनीय तितका चांगला.



3. उपसर्ग आणि पोस्टफिक्स वाढ

तुम्हाला आधीच माहित आहे की, Java मध्ये इन्क्रिमेंट ऑपरेटर ( ++) आणि डिक्रिमेंट ऑपरेटर ( --) आहे. अनुक्रमे, ते व्हेरिएबलचे मूल्य द्वारे वाढवतात आणि कमी करतात 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;

ऑपरेटरसाठी --, सर्वकाही अगदी समान आहे.