வகை மாற்றம்

"இப்போது மிகவும் சுவாரஸ்யமான பகுதிக்கு, வகை மாற்றங்களைப் பற்றி நான் உங்களுக்குச் சொல்கிறேன். மாறிகள் அவற்றின் வகைகளை மாற்ற முடியாது, ஆனால் நீங்கள் வகைகளை மாற்றக்கூடிய இடம் உள்ளது. அந்த இடம் ஒரு அசைன்மென்ட் ஆபரேஷன். "

"நீங்கள் வெவ்வேறு வகையான மாறிகளை ஒருவருக்கொருவர் ஒதுக்கலாம். அவ்வாறு செய்யும்போது, ​​ஒரு மாறியின் (குறிப்பிட்ட வகை) மதிப்பு மற்ற வகையின் மதிப்பாக மாற்றப்பட்டு மற்ற மாறிக்கு ஒதுக்கப்படும். "

"இரண்டு வகையான மாற்றங்களை நாம் சுட்டிக்காட்டலாம்: பழமையான மாற்றங்களை விரிவுபடுத்துதல் மற்றும் பழமையான மாற்றங்களைச் சுருக்குதல். அகலப்படுத்துதல் என்பது ஒரு சிறிய கூடையில் இருந்து ஒரு பெரிய கூடைக்கு பொருட்களை நகர்த்துவது போன்றது. செயல்முறை குறிப்பிடத்தக்கது மற்றும் வலியற்றது. ஒரு பெரிய கூடையில் இருந்து பொருட்களை எடுப்பதற்கு ஒப்பானது. அவற்றைச் சிறியதாக வைக்கலாம். இதைச் செய்யும்போது உங்களிடம் போதுமான இடம் இல்லாமல் போகலாம்; நீங்கள் எதையாவது தூக்கி எறிய வேண்டியிருக்கும். "

"அவற்றின் 'கூடை' அளவின்படி வரிசைப்படுத்தப்பட்ட வகைகள் இங்கே:"

"ஓரிரு கருத்துகள்:

1. சார்'ஸ் பேஸ்கெட், ஷார்ட்'களின் அதே அளவுதான், ஆனால் உங்களால் பொருட்களை ஒன்றிலிருந்து மற்றொன்றுக்கு சுதந்திரமாக நகர்த்த முடியாது. நீங்கள் மதிப்புகளை சுருக்கத்திலிருந்து எழுத்துக்கு நகர்த்தும்போது , ​​​​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);

"நான் பார்க்கிறேன்."