जावा में, बूलियन "संचालन के आदेश" क्या हैं?

Question

चलिए ऑब्जेक्ट Cat का एक साधारण उदाहरण लें। मैं यह सुनिश्चित करना चाहता हूं कि "शून्य नहीं" cat या तो नारंगी या भूरा है।

if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") { 
//do stuff 
} 

मुझे विश्वास है और पहले आता है, फिर OR। मैं थोड़े फजी हालांकि यहाँ हूँ, इसलिए मेरे प्रश्न हैं:

1. कोई इस बयान इतना के माध्यम से मुझे चलना कर सकते हैं मुझे यकीन है कि मैं क्या होता है प्राप्त कर रहा हूँ?

2. इसके अलावा, यदि मैं कोष्ठक जोड़ता हूं तो क्या होता है; क्या यह संचालन के क्रम को बदलता है?

3. क्या मेरे संचालन का क्रम भाषा से भाषा में बदल जाएगा?

Answer 1

जावा ट्यूटोरियल operator precedence को दर्शाता हुआ एक सूची है। समानता ऑपरेटरों का मूल्यांकन पहले किया जाएगा, फिर &&, फिर ||। किसी अन्य चीज़ से पहले माता-पिता का मूल्यांकन किया जाएगा, इसलिए उन्हें जोड़ने से ऑर्डर बदल सकता है। यह आमतौर पर भाषा से भाषा के समान ही होता है, लेकिन जांच को दोबारा देखना हमेशा अच्छा विचार होता है।

यह व्यवहार में छोटी भिन्नता है कि आप उम्मीद नहीं कर रहे हैं कि आप पूरे दिन डिबगिंग खर्च कर सकते हैं, इसलिए कोष्ठक को जगह में रखना अच्छा विचार है ताकि आप सुनिश्चित हो सकें कि मूल्यांकन का आदेश क्या होगा ।

Answer 2

आपरेशन के बूलियन क्रम (सभी भाषाओं में मेरा मानना ​​है कि):

1. कोष्ठक
2. नहीं
3. और
4. या

तो अपने तर्क ऊपर बराबर है प्रति:

(cat != null && cat.getColor() == "orange") || cat.getColor() == "grey" 

Answer 3

पहले, अपने अगर बयान तीन मुख्य भाव शामिल हैं:

1. बिल्ली = अशक्त
2. cat.getColor() == "नारंगी"
3. cat.getColor() == "ग्रे! "

पहली अभिव्यक्ति बस जांचती है कि बिल्ली शून्य नहीं है या नहीं। यह आवश्यक है अन्यथा दूसरी अभिव्यक्ति निष्पादित की जाएगी और परिणामस्वरूप NPE(null pointer excpetion) होगा। यही कारण है कि पहली और दूसरी अभिव्यक्ति के बीच & & का उपयोग। जब आप && का उपयोग करते हैं, तो पहली अभिव्यक्ति गलत होने का मूल्यांकन करती है तो दूसरी अभिव्यक्ति कभी निष्पादित नहीं होती है। अंत में आप जांचते हैं कि बिल्ली का रंग भूरा है या नहीं।

अंत में ध्यान दें कि आपके अगर बयान है अभी भी गलत अगर बिल्ली रिक्त है, तीसरे अभिव्यक्ति अभी भी है, क्योंकि मार डाला है और इसलिए आप एक अशक्त सूचक अपवाद मिलता है।

यह ऐसा करने का सही तरीका है:

if(cat != null && (cat.getColor() == "orange" || cat.getColor() == "grey")) { 
//do stuff 
} 

कोष्टक के आदेश की जाँच करें।

if ((cat != null && cat.getColor() == "orange") || cat.getColor() == "grey") { 
    ... 
} 

प्राथमिकता का क्रम है कि यहाँ है और (&&) से अधिक पूर्वता या (||) है:

Answer 4

अभिव्यक्ति मूल रूप से करने के लिए समान है।

आपको यह भी पता होना चाहिए कि स्ट्रिंग समानता के परीक्षण के लिए == का उपयोग करना कभी-कभी जावा में काम करेगा लेकिन ऐसा नहीं है कि आपको यह कैसे करना चाहिए। आपको क्या करना चाहिए:

if (cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) { 
    ... 
} 

यानी String तुलना, नहीं == जो केवल संदर्भ समानता करता है के लिए equals() तरीकों का उपयोग। तारों के लिए संदर्भ समानता भ्रामक हो सकती है। उदाहरण के लिए:

String a = new String("hello"); 
String b = new String("hello"); 
System.out.println(a == b); // false 

Answer 5

हाँ && निश्चित रूप से || से पहले मूल्यांकन किया जाता है। लेकिन मुझे लगता है कि आप cat.getColor() == "orange" कर रहे हैं जो आपको अप्रत्याशित परिणाम दे सकता है। आप इस के बजाय कर सकते हैं:

if(cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) { 
    //do stuff 
} 

Answer 6

ऑपरेशन के आदेश नहीं है कि तुम क्या जरूरत है, तो आप बूलीय बीजगणित की जरूरत है, इस बूलियन कार्य शामिल हैं। अधिकतम/minterms, ग्रे कोड, कर्णघ टेबल, डायोड, ट्रांजिस्टर, तर्क गेट्स, मल्टीप्लेक्सर्स, बिटडर्स, फ्लिप फ्लॉप ... आप जो चाहते हैं वो कंप्यूटर या आभासी मशीनों पर बूलियन "तर्क" को लागू करना है। "संचालन के आदेश" के साथ आप भौतिकी के बारे में कुछ बता सकते हैं जैसे लॉजिक गेट्स (या, अगर) नैनोसेकंड अंतराल पर देरी प्रबंधन?