प्रकार रूपांतरण

"आणि आता सर्वात मनोरंजक भागासाठी. मी तुम्हाला प्रकार रूपांतरणांबद्दल सांगेन. व्हेरिएबल्स त्यांचे प्रकार बदलू शकत नाहीत, परंतु अशी एक जागा आहे जिथे तुम्ही प्रकार बदलू शकता. ते स्थान एक असाइनमेंट ऑपरेशन आहे. "

"तुम्ही एकमेकांना विविध प्रकारचे व्हेरिएबल नियुक्त करू शकता. असे केल्याने, एका व्हेरिएबलचे (विशिष्ट प्रकाराचे) मूल्य दुसऱ्या प्रकारच्या व्हेरिएबलमध्ये रूपांतरित केले जाते आणि दुसऱ्या व्हेरिएबलला नियुक्त केले जाते. "

"आम्ही दोन प्रकारची रूपांतरणे दर्शवू शकतो: आदिम रूपांतरणे रुंद करणे आणि आदिम रूपांतरणे संकुचित करणे. रुंदीकरण म्हणजे गोष्टी लहान टोपलीतून मोठ्या टोपलीत हलविण्यासारखे आहे. प्रक्रिया अविस्मरणीय आणि वेदनारहित आहे. संकुचित करणे हे मोठ्या टोपलीतून गोष्टी बाहेर काढण्यासारखे आहे. आणि त्यांना एका लहानमध्ये टाकत आहे. जेव्हा तुम्ही हे कराल तेव्हा तुमच्याकडे पुरेशी जागा नसेल; तुम्हाला काहीतरी फेकून द्यावे लागेल .

"त्यांच्या 'बास्केट' आकारानुसार क्रमवारी लावलेले प्रकार येथे आहेत:"

"फक्त दोन टिप्पण्या:

1. चारची बास्केट शॉर्टच्या आकारासारखीच असते, परंतु तुम्ही गोष्टी एका वरून दुसऱ्याकडे मुक्तपणे हलवू शकत नाही. जेव्हा तुम्ही मूल्ये लहान वरून char वर हलवता , तेव्हा 0 पेक्षा कमी असलेली मूल्ये नेहमी गमावली जातील. जेव्हा तुम्ही मूल्ये चारवरून लहान वर हलवता, तेव्हा 32,000 पेक्षा जास्त मूल्ये नष्ट होतील.

2. जेव्हा तुम्ही पूर्णांकांचे अपूर्णांकात रूपांतर करता, तेव्हा त्या संख्येचे किमान महत्त्वाचे अंक बाहेर फेकले जाऊ शकतात. तथापि, हे मान्य आहे, कारण अपूर्णांकाचा उद्देश अंदाजे मूल्य संग्रहित करणे आहे."

" संकुचित रूपांतरणे करत असताना, आम्ही कंपाइलरला स्पष्टपणे सांगायला हवे की आम्ही चूक केलेली नाही: आम्ही हेतुपुरस्सर संख्येचा काही भाग टाकून देत आहोत. हे करण्यासाठी आम्ही कास्ट ऑपरेटर ( म्हणजे कंसात टाइप नाव ) वापरतो."

"तुम्ही वेगवेगळ्या प्रकारचे व्हेरिएबल्स असाइन केले पाहिजेत:"

byte a = 115;
int b = a;

int c = 10000;
byte d = (byte) c;

int c = 10;
byte d = (byte) c;

float f = 10000;
long l = (long) (f * f);
float f2 = l;
long l2 = (long) f2;

double d = 1;
float f = (float) d;
long l = (long) f;
int i = (int) l;
short s = (short) i;
byte b = (byte) s;

" कास्ट ऑपरेटरला संख्या/व्हेरिएबलच्या आधी ठेवणे आवश्यक आहे जेव्हा नंबरचा काही भाग टाकून दिला जाईल किंवा जेव्हा संकुचित प्रिमिटिव्ह रूपांतरण होते. कास्ट ऑपरेटर फक्त त्या संख्या/व्हेरिएबलला प्रभावित करतो जे थेट त्याचे अनुसरण करतात."

float f = 10000;
long l = (long) f * f;

float f = 10000;
long l = (long) (f * f);

"मी बघतो."