विभिन्न ऑपरेटरों के साथ काम करने की बारीकियां

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, तो ऑपरेटर के बाईं ओर का भाग &&है false, तो संपूर्ण बूलियन अभिव्यक्ति का परिणाम है false, इसलिए दाईं ओर के भाग ( s.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;

ऑपरेटर के लिए --सब कुछ बिल्कुल वैसा ही है।