जावा में ऑपरेटर (Operators in Java)

ए. ऑपरेंड गणना द्वारा वर्गीकरण:

• यूनरी ऑपरेटर्स: सिंगल ऑपरेंड पर काम करते हैं। (जैसे, यूनरी प्लस +a, यूनरी माइनस -a, इंक्रीमेंट ++a, डिक्रीमेंट --a, लॉजिकल नॉट !फ्लैग).
• बाइनरी ऑपरेटर्स: दो ऑपरेंड पर काम करते हैं। (उदाहरण के लिए, जोड़ a + b, गुणन a * b, समानता a == b, तार्किक और a && b).
• टर्नरी ऑपरेटर: तीन ऑपरेंड पर संचालित होता है। जावा में, केवल एक टर्नरी ऑपरेटर है: कंडीशनल ऑपरेटर (condition ? expr1 : expr2).

बी. अंकगणित संचालक (गणना इंजन):

मापांक चिह्न नियम: a % b का परिणाम हमेशा अंक (प्रथम ऑपरेंड) का बीजगणितीय चिह्न रखता है: -10 % 3 = -1; 10 % -3 = 1; -10 % -3 = -1.

ए. मौलिक भेद:

• उपसर्ग फॉर्म (++x / --x): बदलें-फिर-उपयोग
  वेरिएबल का मान 1 पहले बढ़ाया (या घटाया गया) है, और फिर नए अद्यतन मूल्य का उपयोग आसपास की अभिव्यक्ति में किया जाता है।
• पोस्टफिक्स फॉर्म (x++ / x--): उपयोग-फिर-बदलें
  वेरिएबल का वर्तमान मूल मान आसपास के अभिव्यक्ति पहले में उपयोग किया जाता है, और मूल्यांकन के बाद ही मेमोरी में वेरिएबल को 1 से बढ़ाया (या घटाया) जाता है।

बी. चरण-दर-चरण मूल्यांकन ट्रेस तालिका (क्लासिक आईसीएसई प्रश्न):

समस्या: यदि int a = 5, b = 3; मूल्यांकन करें: int c = ++a * 2 + b++ * --a - a--;

गणितीय प्रतिस्थापन: c = (6 * 2) + (3 * 5) - 5;
सी = 12 + 15 - 5 = 22;
अंतिम परिवर्तनीय स्थितियाँ: c = 22, a = 4, b = 4.

ए. रिलेशनल ऑपरेटर्स (उत्पादन बूलियन):

दो संख्यात्मक या वर्ण मानों की तुलना करने के लिए उपयोग किया जाता है: == (बराबर), != (बराबर नहीं), >, <, >=, <=.

बी. लॉजिकल ऑपरेटर्स और शॉर्ट-सर्किट व्यवहार:

• तार्किक और (&&): रिटर्न सत्य यदि और केवल यदि दोनों ऑपरेंड सत्य हैं।
  शॉर्ट-सर्किट नियम: यदि बायां ऑपरेंड गलत का मूल्यांकन करता है, तो समग्र अभिव्यक्ति कभी भी सत्य नहीं हो सकती है। इसलिए, जावा पूरी तरह से सही ऑपरेंड का मूल्यांकन करना छोड़ देता है!
  उदाहरण: if (x != 0 && (100 / x) > 5) → यदि x == 0, तो विभाजन का प्रयास कभी नहीं किया जाता है, सुरक्षित रूप से ArithmeticException को रोका जाता है: / शून्य द्वारा!
• तार्किक या (||): रिटर्न सत्य यदि कम से कम एक ऑपरेंड सत्य है।
  शॉर्ट-सर्किट नियम: यदि बायां ऑपरेंड सत्य का मूल्यांकन करता है, तो समग्र अभिव्यक्ति पहले से ही सत्य होने की गारंटी है। जावा सही ऑपरेंड का मूल्यांकन करना छोड़ देता है!
• तार्किक नहीं (!): यूनरी ऑपरेटर जो सत्य मान को उलट देता है (!सत्य = असत्य; !असत्य = सत्य).

ए. सिंटेक्स और मैकेनिक्स:

चर = (स्थिति) ? अभिव्यक्ति_यदि_सत्य : अभिव्यक्ति_यदि_झूठा;

पहले स्थिति का मूल्यांकन किया जाता है. यदि यह true देता है, तो expression_if_true का मूल्यांकन किया जाता है और लौटाया जाता है; अन्यथा, expression_if_false का मूल्यांकन किया जाता है और लौटाया जाता है।

बी. if-else से टर्नरी:

if (अंक >=40)
    परिणाम = "पास";
अन्यथा
    परिणाम = "विफल";

परिणाम = (अंक >=40) ? "उत्तीर्ण" : "असफल";

if (ए > बी)
    अधिकतम = (ए > सी) ? ए : सी;
अन्यथा
    अधिकतम = (बी > सी) ? बी : सी;

अधिकतम = (ए > बी) ? ((a > c) ? a : c) : ((b > c) ? b : c);

मूल्यांकन पदानुक्रम (उच्चतम से निम्नतम):

समस्या 1: जटिल पोस्टफ़िक्स और उपसर्ग संयोजन

अभिव्यक्ति: यदि int x = 10, y = 12; मूल्यांकन करें: int z = ++x * (y++ - --x) + y--;

• ++x: x 10 से 11 में बदलता है। (प्रयुक्त मूल्य: 11)
• y++: y वर्तमान में 12 है, फिर 13 तक बढ़ जाता है। (प्रयुक्त मूल्य: 12)
• --x: x 11 से 10 तक बदलता है। (प्रयुक्त मूल्य: 10)
• अंदरूनी कोष्ठक: (12 - 10) = 2.
• y--: y वर्तमान में 13 है, फिर घटकर 12 हो जाता है। (प्रयुक्त मूल्य: 13)
• मूल्यांकन: z = 11 * 2 + 13 = 22 + 13 = 35.
• अंतिम स्थिति: z = 35, x = 10, y = 12.

समस्या 2: व्यापक वृद्धि और संबंधपरक मूल्यांकन

अभिव्यक्ति: यदि int a = 4, b = 7; मूल्यांकन करें: बूलियन ध्वज = (++a * 3 > b--) && (a++ + --b < 15);

• बायाँ संकार्य: ++a a = 5 बनाता है। (मान: 5)। बी-- 7 का उपयोग करता है, फिर बी 6 हो जाता है।
• बाएं तुलना: (5 * 3 > 7) → (15 > 7) → सत्य.
• चूंकि && का बायां हिस्सा सत्य है, इसलिए दाएं पक्ष का मूल्यांकन किया जाना चाहिए!
• दायाँ ऑपरेंड: a++ 5 का उपयोग करता है, फिर a 6 हो जाता है। --b b को 6 से 5 तक घटाता है (मान: 5).
• सही तुलना: (5 + 5 < 15) → (10 < 15) → सत्य.
• कुल मिलाकर: सत्य && सत्य → सत्य.
• अंतिम स्थिति: ध्वज = सत्य, ए = 6, बी = 5.

विस्तृत चरण-दर-चरण अभिव्यक्ति समाधान:

ड्रिल 1: यदि int m = 12; मूल्यांकन करें: m = m++ + ++m - m-- + --m;

• m++: 12 का उपयोग करता है, m 13 हो जाता है।
• ++m: m 14 हो जाता है, 14 का उपयोग करता है।
• m--: 14 का उपयोग करता है, m 13 हो जाता है।
• --m: m 12 हो जाता है, 12.
का उपयोग करता है
• परिणाम: m = 12 + 14 - 14 + 12 = 24.

ड्रिल 2: यदि int a = 5, b = 2; मूल्यांकन करें: int res = a++ * 2 + --b * a;

• a++ 5 का उपयोग करता है, तो a 6 हो जाता है।
• --बी कमी बी 2 से 1 तक, उपयोग 1.
• इसके बाद a अब 6.
है
• गणित: (5 * 2) + (1 * 6) = 10 + 6 = 16.
• अंतिम स्थिति: रेस = 16, ए = 6, बी = 1.

ड्रिल 3: यदि int x = 7; मूल्यांकन करें: x += x++ + ++x + x;

• मूल x = 7. दाईं ओर: x++ 7 का उपयोग करता है, x 8 हो जाता है। ++x 9 बन जाता है, 9 का उपयोग करता है। अंतिम x = 9.
• योग: 7 + 9 + 9 = 25.
• x += 25 → x = 7 + 25 = 32.

ए. बिट-लेवल मैनिपुलेशन ऑपरेटर्स:

चरण-दर-चरण अभिव्यक्ति समाधान:

समस्या 4: यदि int a = 10, b = 20; मूल्यांकन करें: int c = a++ + ++b * --a / 5;

• a++ 10 का उपयोग करने पर, a 11 हो जाता है।
• ++b वेतन वृद्धि b 20 से 21, उपयोग 21.
• --a a को 11 से घटाकर 10 करता है, 10.
का उपयोग करता है
• गुणात्मक पूर्वता (* और / की समान पूर्वता है, बाएँ से दाएँ मूल्यांकन किया गया है):
• 21 * 10 = 210
• 210 / 5 = 42
• अतिरिक्त: c = 10 + 42 = 52.
• अंतिम आउटपुट: सी = 52, ए = 10, बी = 21.

समस्या 5: यदि int x = 3; मूल्यांकन करें: x = x++ * x++ * ++x;

• पहले x++ 3 का उपयोग करता है, x 4 बन जाता है।
• दूसरा x++ 4 का उपयोग करता है, x 5 हो जाता है।
• ++x वृद्धि x 5 से 6, उपयोग 6.
• गणित: x = 3 * 4 * 6 = 72.
• अंतिम आउटपुट: x = 72.

ए. लॉजिकल ऑपरेटर ट्रुथ टेबल (ए, बी बूलियन):

बी. असाइनमेंट बनाम समानता तुलना:

एकल बराबर चिह्न = असाइनमेंट ऑपरेटर है जो दाएं हाथ के ऑपरेंड के मान को बाएं हाथ के चर में संग्रहीत करता है (उदाहरण के लिए, int x = 10;)। दोहरा बराबर चिह्न == रिलेशनल इक्वेलिटी ऑपरेटर है जो दो मानों की तुलना करता है और एक बूलियन (true या false) लौटाता है। जावा में, if (x = 10) लिखने से एक संकलन त्रुटि उत्पन्न होती है क्योंकि जावा सशर्त अभिव्यक्तियों के अंदर पूर्णांक निर्दिष्ट करने से सख्ती से मना करता है।

ए. शॉर्टहैंड असाइनमेंट ऑपरेटर्स:

कंपाउंड असाइनमेंट ऑपरेटर असाइनमेंट के साथ अंकगणित या बिटवाइज़ ऑपरेशन को जोड़ते हैं: +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=.

इम्प्लिसिट कास्टिंग लाभ: जावा में, कंपाउंड असाइनमेंट ऑपरेटर स्वचालित रूप से एक इंप्लिसिट टाइप कास्ट करते हैं! उदाहरण के लिए, यदि byte b = 10;, b = b + 1; लिखना संकलित करने में विफल रहता है क्योंकि b + 1 एक int का मूल्यांकन करता है। हालाँकि, b += 1; लिखना पूरी तरह से कानूनी है क्योंकि यह b = (बाइट)(b + 1);.

हमेशा याद रखें कि कोष्ठक के अंदर के भावों का मूल्यांकन सर्वोच्च प्राथमिकता के साथ किया जाता है। जटिल बूलियन तर्क का मूल्यांकन करते समय, अभिव्यक्ति को अलग-अलग संबंधपरक उप-स्थितियों में तोड़ें और AND और OR ऑपरेटरों के लिए शॉर्ट-सर्किट मूल्यांकन का सम्मान करते हुए सख्त ऑपरेटर पदानुक्रम के अनुसार उनका मूल्यांकन करें।

सभी जटिल अभिव्यक्तियों में, गुणा, भाग और मापांक संक्रियाओं को हमेशा जोड़ और घटाव पर प्राथमिकता दी जाती है। जब संचालन में समान प्राथमिकता स्तर होते हैं, तो मूल्यांकन बाएं से दाएं की ओर सख्ती से आगे बढ़ता है, असाइनमेंट, यूनरी और टर्नरी ऑपरेटरों को छोड़कर, जो दाएं से बाएं मूल्यांकन करते हैं।