java - सी प्रोग्रामिंग इन हिंदी नोट्स pdf




यदि किसी सरणी से कॉपी किया गया था, तो जावा को अंतिम चर पर एक स्पष्ट कलाकारों की आवश्यकता क्यों है? (2)

निम्नलिखित कोड के साथ शुरू ...

byte foo = 1;
byte fooFoo = foo + foo;

जब मैं इस कोड को संकलित करने का प्रयास करूंगा तो मुझे निम्नलिखित त्रुटि मिलेगी ...

त्रुटि: (५, २ava) जावा: असंगत प्रकार: संभव हानिपूर्ण रूपांतरण बाइट से इंट तक

... लेकिन अगर foo अंतिम है ...

final byte foo = 1;
final byte fooFoo = foo + foo;

फ़ाइल सफलतापूर्वक संकलित होगी।

निम्न कोड पर आगे बढ़ रहा है ...

final byte[] fooArray = new byte[1];
fooArray[0] = 1;

final byte foo = fooArray[0];
fooArray[0] = 127;

System.out.println("foo is: " + foo);

... छपेगा

foo is: 1

... जो ठीक है। मान को एक अंतिम चर में कॉपी किया जाता है और इसे किसी भी अधिक नहीं बदला जा सकता है। सरणी में मान के साथ खेलने से foo का मान नहीं बदलता (जैसा कि अपेक्षित है ...)।

निम्नलिखित में कलाकारों की आवश्यकता क्यों है?

final byte[] fooArray = new byte[1];
fooArray[0] = 1;
final byte foo = fooArray[0];
final byte fooFoo = foo + foo;

इस प्रश्न में यह दूसरे उदाहरण से कैसे भिन्न है? कंपाइलर मुझे निम्न त्रुटि क्यों दे रहा है?

त्रुटि: (५, २ava) जावा: असंगत प्रकार: संभव हानिपूर्ण रूपांतरण बाइट से इंट तक

ये केसे हो सकता हे?


JLS ( §5.2 ) में निरंतर अभिव्यक्ति के साथ असाइनमेंट रूपांतरण के लिए विशेष नियम हैं:

इसके अलावा, यदि अभिव्यक्ति प्रकार byte , short , char या int का एक स्थिर अभिव्यक्ति ( §15.28 ) है:

  • एक संकरा आदिम रूपांतरण का उपयोग किया जा सकता है यदि चर का प्रकार byte , short या char , और निरंतर अभिव्यक्ति का मूल्य चर के प्रकार में प्रतिनिधित्व करने योग्य है।

यदि हम उपरोक्त लिंक का अनुसरण करते हैं, तो हम इन्हें निरंतर अभिव्यक्ति की परिभाषा में देखते हैं:

  • आदिम प्रकार के साहित्य और प्रकार String शाब्दिक
  • योजक संचालक + और -
  • सरल नाम ( §6.5.6.1 ) जो निरंतर चर ( §4.12.4 ) को संदर्भित करते हैं।

यदि हम ऊपर दिए गए दूसरे लिंक का अनुसरण करते हैं, तो हम देखते हैं कि

आदिम प्रकार या प्रकार String का एक चर, जो final और एक संकलन-समय स्थिर अभिव्यक्ति () §15.28 ) के साथ प्रारंभ होता है, एक स्थिर चर कहा जाता है।

यह अनुसरण करता है कि foo + foo को केवल fooFoo को सौंपा जा सकता है यदि foo एक स्थिर चर है । अपने मामलों पर लागू करने के लिए:

  • byte foo = 1; एक स्थिर चर को परिभाषित नहीं करता है क्योंकि यह final नहीं है।

  • final byte foo = 1; एक स्थिर चर को परिभाषित करता है , क्योंकि यह final और एक स्थिर अभिव्यक्ति (एक आदिम शाब्दिक) के साथ प्रारंभ होता है।

  • final byte foo = fooArray[0]; एक स्थिर चर को परिभाषित नहीं करता है क्योंकि यह एक स्थिर अभिव्यक्ति के साथ आरंभिक नहीं है।

ध्यान दें कि क्या fooFoo ही final इससे कोई फर्क नहीं पड़ता।


मान 1 बाइट में अच्छी तरह से फिट बैठता है; तो 1 + 1 करता है; और जब चर अंतिम होता है, संकलक निरंतर तह कर सकता है । (दूसरे शब्दों में: कंपाइलर उस + ऑपरेशन को करते समय foo उपयोग नहीं करता है; लेकिन "कच्चा" 1 मान)

लेकिन जब चर अंतिम नहीं होता है, तो रूपांतरण और प्रचार के बारे में सभी दिलचस्प नियम किक करते हैं ( here देखें; आप आदिम रूपांतरणों के बारे में खंड 5.12 पढ़ना चाहते हैं)।

दूसरे भाग के लिए: एक सरणी फ़ाइनल बनाने के बाद भी आप इसके किसी भी क्षेत्र को बदल सकते हैं; इसलिए फिर से; कोई निरंतर तह संभव नहीं; ताकि "चौड़ीकरण" कार्रवाई फिर से शुरू हो जाए।






byte