जवाबों:
दो ऑपरेंड (1 और 3) पूर्णांक हैं, इसलिए पूर्णांक अंकगणित (यहां विभाजन) का उपयोग किया जाता है। परिणाम चर को दोहरे के रूप में घोषित करने से विभाजन के बाद एक अंतर्निहित रूपांतरण होता है ।
पूर्णांक विभाजन निश्चित रूप से शून्य की ओर गोल विभाजन का सही परिणाम देता है। इस 0.333...प्रकार परिणाम यहाँ 0 से नीचे गोल है। (ध्यान दें कि प्रोसेसर वास्तव में कोई राउंडिंग नहीं करता है, लेकिन आप इसके बारे में अभी भी सोच सकते हैं।)
यह भी ध्यान दें कि यदि दोनों ऑपरेंड (संख्या) फ्लोट के रूप में दिए गए हैं; 3.0 और 1.0, या यहां तक कि सिर्फ पहले , फिर फ्लोटिंग-पॉइंट अंकगणितीय का उपयोग किया जाता है, आपको 0.333...।
1/3 पूर्णांक विभाजन का उपयोग करता है क्योंकि दोनों पक्ष पूर्णांक हैं।
आपको उनमें से कम से कम एक floatया होने की आवश्यकता है double।
यदि आप अपने प्रश्न जैसे स्रोत कोड में मान दर्ज कर रहे हैं, तो आप कर सकते हैं 1.0/3; 1.0एक डबल है।
आप कहीं और से मान मिलता है, तो आप उपयोग कर सकते (double)चालू करने के लिए intएक में double।
int x = ...;
int y = ...;
double value = ((double) x) / y;आपको उपयोग करना चाहिए
double g=1.0/3;या
double g=1/3.0;पूर्णांक विभाजन पूर्णांक देता है।
क्योंकि आप पूर्णांक विभाजन कर रहे हैं।
जैसा कि @ नोल्डोरिन कहते हैं, यदि दोनों ऑपरेटर पूर्णांक हैं, तो पूर्णांक विभाजन का उपयोग किया जाता है।
परिणाम 0.33333333 को पूर्णांक के रूप में नहीं दर्शाया जा सकता है, इसलिए केवल पूर्णांक भाग (0) को परिणाम को सौंपा गया है।
यदि कोई भी ऑपरेटर double/ है float, तो फ्लोटिंग पॉइंट अंकगणित होगा। लेकिन अगर आप ऐसा करते हैं तो आपको वही समस्या होगी:
int n = 1.0 / 3.0;क्योंकि यह 1 और 3 को पूर्णांक मानता है, इसलिए परिणाम को 0 से नीचे कर रहा है, ताकि यह पूर्णांक हो।
आप जिस परिणाम की तलाश कर रहे हैं, उसे पाने के लिए, स्पष्ट रूप से जावा को बताएं कि संख्याएँ इस तरह दोगुनी हैं:
double g = 1.0/3.0;जेएवीए में रूपांतरण काफी सरल है, लेकिन कुछ समझ की आवश्यकता है। पूर्णांक संचालन के लिए जेएलएस में समझाएं :
यदि शिफ्ट ऑपरेटर के अलावा एक पूर्णांक ऑपरेटर में कम से कम एक प्रकार का ऑपरेंड होता है, तो 64-बिट परिशुद्धता का उपयोग करके ऑपरेशन किया जाता है, और संख्यात्मक ऑपरेटर का परिणाम टाइप लंबा होता है। यदि अन्य ऑपरेंड लंबा नहीं है, तो पहले संख्यात्मक प्रसार (..6.6) द्वारा लंबे टाइप करने के लिए इसे (.55.1.5) चौड़ा किया जाता है।
और एक उदाहरण हमेशा जेएलएस का अनुवाद करने का सबसे अच्छा तरीका है;)
int + long -> long
int(1) + long(2) + int(3) -> long(1+2) + long(3)अन्यथा, 32-बिट परिशुद्धता का उपयोग करके ऑपरेशन किया जाता है, और संख्यात्मक ऑपरेटर का परिणाम टाइप इंट का है। यदि या तो ऑपरेंड एक इंट नहीं है, तो इसे पहले संख्यात्मक प्रचार द्वारा इंट टाइप करने के लिए चौड़ा किया जाता है।
short + int -> int + int -> intग्रहण का उपयोग करने के लिए एक छोटा सा उदाहरण है कि दो shorts का जोड़ भी इतना आसान नहीं होगा:
short s = 1;
s = s + s; <- Compiling error
//possible loss of precision
// required: short
// found: intयह परिशुद्धता के संभावित नुकसान के साथ एक कास्टिंग की आवश्यकता होगी।
फ्लोटिंग पॉइंट ऑपरेटरों के लिए भी यही सच है
यदि एक संख्यात्मक ऑपरेटर के लिए ऑपरेंड में से कम से कम एक प्रकार डबल है, तो 64-बिट फ्लोटिंग-पॉइंट अंकगणितीय का उपयोग करके ऑपरेशन किया जाता है, और संख्यात्मक ऑपरेटर का परिणाम टाइप डबल का एक मूल्य है। यदि अन्य ऑपरेंड एक डबल नहीं है, तो संख्यात्मक प्रमोशन (.5.6) द्वारा डबल टाइप करने के लिए इसे पहले (.55.1.5) चौड़ा किया जाता है।
तो पदोन्नति डबल में फ्लोट पर की जाती है।
और पूर्णांक और फ्लोटिंग वैल्यू दोनों के मिश्रण के फलस्वरूप फ्लोटिंग वैल्यू में परिवर्तन होता है
यदि बाइनरी ऑपरेटर में से कम से कम एक ऑपरेंड फ्लोटिंग-पॉइंट प्रकार का है, तो ऑपरेशन फ़्लोटिंग-पॉइंट ऑपरेशन है, भले ही दूसरा अभिन्न हो।
यह बाइनरी ऑपरेटरों के लिए सच है, लेकिन "असाइनमेंट ऑपरेटर्स" जैसे के लिए नहीं +=
एक सरल कार्यशील उदाहरण यह साबित करने के लिए पर्याप्त है
int i = 1;
i += 1.5f;कारण यह है कि यहां एक निहित कास्ट है, इस तरह निष्पादित किया जाएगा
i = (int) i + 1.5f
i = (int) 2.5f
i = 2सबसे आसान उपाय बस यही करना है
double g = ((double) 1 / 3);यह क्या करता है, क्योंकि आपने 1.0 / 3.0 दर्ज नहीं किया है, आपको मैन्युअल रूप से इसे डेटा टाइप डबल में बदलने देता है क्योंकि जावा ने माना कि यह इंटेगर डिवीजन था, और यह तब भी करेगा जब इसका अर्थ रूपांतरण को कम करना होगा। इसे ही कास्ट ऑपरेटर कहा जाता है।
इसे मैने किया है।
double g = 1.0/3.0;
System.out.printf("%gf", g);डबल गणना करते समय .0 का प्रयोग करें या फिर जावा मान लेगा कि आप इंटिजर्स का उपयोग कर रहे हैं। यदि कोई गणना किसी भी दोहरे मान का उपयोग करता है, तो आउटपुट एक डबल मान होगा। यदि सभी इंटेगर हैं, तो आउटपुट एक इंटेगर होगा।
(1/3) का अर्थ है इंटीजर डिवीजन, यही कारण है कि आप इस डिवीजन से दशमलव मान प्राप्त नहीं कर सकते हैं। इस समस्या को हल करने के लिए:
public static void main(String[] args) {
double g = 1.0 / 3;
System.out.printf("%.2f", g);
}public static void main(String[] args) {
double g = 1 / 3;
System.out.printf("%.2f", g);
}चूँकि 1 और 3 दोनों सम्मिलित हैं, परिणाम गोल नहीं है, लेकिन यह छोटा है। इसलिए आप भिन्नों को नजरअंदाज करें और केवल फुर्ती लें
इससे बचने के लिए कम से कम आपकी संख्या 1 या 3 एक दशमलव रूप 1.0 और / या 3.0 के रूप में है।
इसे आज़माएं:
public static void main(String[] args) {
double a = 1.0;
double b = 3.0;
double g = a / b;
System.out.printf(""+ g);
}"डबल जी = 1.0 / 3.0;" बजाय।
कई अन्य वास्तविक मुद्दे को इंगित करने में विफल रहे हैं:
केवल पूर्णांक पर एक ऑपरेशन एक पूर्णांक के लिए ऑपरेशन का परिणाम निकालता है।
यह जरूरी है कि फ्लोटिंग पॉइंट परिणाम, जिसे पूर्णांक के रूप में प्रदर्शित किया जा सकता है, काट दिया जाएगा (दशमलव भाग को बंद करें)।
क्या है कास्टिंग (typecasting / जैसे रूपांतरण) आप से पूछना?
यह भाषा के कार्यान्वयन पर भिन्न होता है, लेकिन विकिपीडिया में एक व्यापक दृष्टिकोण है, और यह जबरदस्ती के बारे में भी बात करता है , जो आपके प्रश्न का उत्तर देने में जानकारी का एक महत्वपूर्ण हिस्सा है।
1/2नहीं है, लक्ष्य भाषा (जावा) में नहीं। आप बस एक पूर्णांक विभाजन लागू करते हैं, जिसके परिणामस्वरूप पूर्णांक परिणाम होगा। प्रकार कास्टिंग केवल से अप-रूपांतरण की वजह से है intएक करने के लिए doubleकाम के दौरान।
0.5। बस, जावा में, 1/2एक पूर्णांक विभाजन है, जिसके परिणामस्वरूप शून्य पूर्णांक होता है। आप एक शून्य को एक डबल को असाइन कर सकते हैं, यह अभी भी एक शून्य होगा, भले ही एक 0.0डबल हो।
int i = .999999990. से अधिक सेट करता है। विशेष रूप से, यह पूर्णांक भाग लेता है और बाकी को हटा देता है।