ஜாவாவில் தட்டச்சு செய்தல்

1. தட்டச்சு செய்தல்

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

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

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

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

2. விரிவுபடுத்தும் வகை மாற்றங்கள்

ஒரு எண் வகையின் மாறியை மற்றொரு எண் வகையின் மாறிக்கு ஒதுக்குவது பெரும்பாலும் அவசியம். அதை நீ எப்படி செய்கிறாய்?

ஜாவாவில் 4 முழு எண் வகைகள் உள்ளன:

சிறிய கூடைகளில் சேமிக்கப்படும் மாறி எப்போதும் பெரிய கூடைகளில் சேமிக்கப்படும் மாறிகளுக்கு ஒதுக்கப்படும்.

int, shortமற்றும் byteமாறிகளை மாறிகளுக்கு எளிதாக ஒதுக்கலாம் long. shortமற்றும் byteமாறிகளுக்கு மாறிகள் ஒதுக்கப்படலாம் int. மேலும் byteமாறிகளுக்கு மாறிகளை ஒதுக்கலாம் short.

எடுத்துக்காட்டுகள்:

byte a = 5;
short b = a;
int c = a + b;
long d = c * c;

சிறிய வகையிலிருந்து பெரிய வகைக்கு இத்தகைய மாற்றத்தை விரிவுபடுத்தும் வகை மாற்றம் என்று அழைக்கப்படுகிறது.

உண்மையான எண்களைப் பற்றி என்ன?

அவர்களுடன், எல்லாம் ஒன்றுதான் - அளவு முக்கியமானது:

floatஎந்த பிரச்சனையும் இல்லாமல் மாறிகளுக்கு மாறிகளை ஒதுக்கலாம் double. ஆனால் முழு எண் வகைகளில் விஷயங்கள் மிகவும் சுவாரஸ்யமானவை.

ஒரு மாறிக்கு எந்த முழு எண் மாறியையும் ஒதுக்கலாம் float. long8 பைட்டுகள் நீளம் கொண்ட வகை கூட . floatநீங்கள் விரும்பும் எதையும் - எந்த முழு எண் மாறி அல்லது மாறி - ஒரு மாறிக்கு ஒதுக்கலாம் double:

long a = 1234567890;
float b = a;
double c = a;

b == 1.23456794E9
c == 1.23456789E9

உண்மையான வகைக்கு மாற்றுவது போதுமான குறிப்பிடத்தக்க இலக்கங்கள் இல்லாததால் துல்லியத்தை இழக்க நேரிடும் என்பதை நினைவில் கொள்ளவும்.

முழு எண்களிலிருந்து மிதக்கும் புள்ளி எண்களாக மாற்றும் போது, ​​எண்களின் கீழ் வரிசைப் பகுதிகள் நிராகரிக்கப்படலாம். ஆனால் பின்ன எண்கள் தோராயமான மதிப்புகளைச் சேமிப்பதற்காகப் புரிந்து கொள்ளப்படுவதால், அத்தகைய ஒதுக்கீட்டுச் செயல்பாடுகள் அனுமதிக்கப்படுகின்றன.

3. குறுகலான வகை மாற்றங்கள்

மற்ற சாத்தியங்களைப் பற்றி என்ன? longஒரு மாறிக்கு மதிப்பை ஒதுக்க வேண்டுமானால் என்ன செய்வது int?

ஒரு மாறியை ஒரு கூடையாக கற்பனை செய்து பாருங்கள். எங்களிடம் பல்வேறு அளவுகளில் கூடைகள் உள்ளன: 1, 2, 4 மற்றும் 8 பைட்டுகள். ஆப்பிள்களை சிறிய கூடையிலிருந்து பெரியதாக மாற்றுவது ஒரு பிரச்சனையல்ல. ஆனால் ஒரு பெரிய கூடையிலிருந்து சிறியதாக மாற்றும்போது, ​​சில ஆப்பிள்கள் இழக்கப்படலாம்.

இந்த மாற்றம் - பெரிய வகையிலிருந்து சிறிய வகைக்கு - குறுகலான வகை மாற்றம் என்று அழைக்கப்படுகிறது . இது போன்ற ஒரு அசைன்மென்ட் செயல்பாட்டைச் செய்யும்போது, ​​ஒரு எண்ணின் ஒரு பகுதி புதிய மாறியில் பொருந்தாமல் இருக்கலாம், அதனால் நிராகரிக்கப்படலாம்.

ஒரு வகையைச் சுருக்கும்போது, ​​​​நாம் தவறு செய்யவில்லை, எண்ணின் ஒரு பகுதியை வேண்டுமென்றே நிராகரிக்கிறோம் என்று கம்பைலரிடம் வெளிப்படையாகச் சொல்ல வேண்டும். இதற்கு டைப்காஸ்ட் ஆபரேட்டர் பயன்படுத்தப்படுகிறது. அடைப்புக்குறிக்குள் இது ஒரு வகை பெயர் .

இதுபோன்ற சூழ்நிலைகளில், ஜாவா கம்பைலருக்கு புரோகிராமர் டைப்காஸ்ட் ஆபரேட்டரைக் குறிப்பிட வேண்டும். பொதுவாக, இது போல் தெரிகிறது:

(type) expression

எடுத்துக்காட்டுகள்:

long a = 1;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

இங்கே aசமமாக உள்ளது 1, ஒருவேளை டைப்காஸ்ட் ஆபரேட்டர் ஓவர்கில் போல் தெரிகிறது. ஆனால் aபெரியதாக இருந்தால் என்ன செய்வது?

long a = 1000000;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

a == 1000000
b == 1000000
c == 16960
d == 64

ஒரு மில்லியன் ஒரு longமற்றும் ஒரு int. ஆனால் ஒரு மாறிக்கு ஒரு மில்லியனை ஒதுக்கும்போது short, ​​முதல் இரண்டு பைட்டுகள் நிராகரிக்கப்படும், கடைசி இரண்டு பைட்டுகள் மட்டுமே தக்கவைக்கப்படும். ஒரு க்கு ஒதுக்கும் போது byte, ​​கடைசி பைட் மட்டுமே எஞ்சியிருக்கும்.

நினைவகத்தில் எண்கள் எவ்வாறு வரிசைப்படுத்தப்படுகின்றன:

charவகை

A char, ஒரு போன்ற short, இரண்டு பைட்டுகளை ஆக்கிரமித்துள்ளது, ஆனால் ஒன்றை மற்றொன்றுக்கு மாற்ற, நீங்கள் எப்போதும் டைப்காஸ்ட் ஆபரேட்டரைப் பயன்படுத்த வேண்டும். இங்குள்ள சிக்கல் என்னவென்றால், வகை கையொப்பமிடப்பட்டுள்ளது மற்றும் லிருந்து shortமதிப்புகளைக் கொண்டிருக்கலாம் , ஆனால் வகை கையொப்பமிடப்படாதது மற்றும் இருந்து மதிப்புகளைக் கொண்டிருக்கலாம் .-32,768+32,767char065,535

எதிர்மறை எண்களை a இல் சேமிக்க முடியாது char, ஆனால் அவை a இல் சேமிக்கப்படும் short. மேலும் a ஐ shortவிட பெரிய எண்களை சேமிக்க முடியாது 32,767, ஆனால் அத்தகைய எண்களை a இல் சேமிக்க முடியும் char.

4. வெளிப்பாட்டின் வகை

வெவ்வேறு வகையான மாறிகள் ஒரே வெளிப்பாட்டில் பயன்படுத்தப்பட்டால் என்ன செய்வது? தர்க்கரீதியாக, அவை முதலில் பொதுவான வகைக்கு மாற்றப்பட வேண்டும் என்பதை நாங்கள் புரிந்துகொள்கிறோம். ஆனால் எது?

பெரியவருக்கு, நிச்சயமாக.

ஜாவா எப்போதும் பெரிய வகைக்கு மாறும். தோராயமாகச் சொன்னால், வகைகளில் ஒன்று முதலில் விரிவுபடுத்தப்படுகிறது, அதன் பிறகுதான் அதே வகையின் மதிப்புகளைப் பயன்படுத்தி செயல்பாடு செய்யப்படுகிறது.

ஒரு வெளிப்பாட்டில் a intமற்றும் a இருந்தால், இன் மதிப்பு a ஆக மாற்றப்படும், அதன் பிறகுதான் செயல்பாடு தொடரும்:longintlong

int a = 1;
long b = 2;
long c = a + b;

மிதக்கும் புள்ளி எண்கள்

ஒரு முழு எண் மற்றும் மிதக்கும்-புள்ளி எண் ( floatஅல்லது ) ஒரு வெளிப்பாட்டில் ஈடுபட்டிருந்தால், முழு எண் ஒரு மிதக்கும்-புள்ளி எண்ணாக ( அல்லது ) doubleமாற்றப்படும் , அதன் பிறகுதான் செயல்பாடு செய்யப்படும்.floatdouble

செயல்பாட்டில் a floatமற்றும் a இருந்தால் double, அது floata ஆக மாற்றப்படும் double. இது உண்மையில் எதிர்பார்க்கப்படுகிறது.

bytea ஆல் பெருக்கினால் short, உங்களுக்கு ஒரு கிடைக்கும் int. bytea ஆல் பெருக்கினால் byte, உங்களுக்கு ஒரு கிடைக்கும் int. byteஒரு மற்றும் ஒரு சேர்த்தாலும் byte, உங்களுக்கு ஒரு கிடைக்கும் int.

இதற்கு பல காரணங்கள் உள்ளன. எடுத்துக்காட்டுகள்:

byte a = 110;
byte b = 120;
byte c = a * b;  // Error

byte a = 110;
byte b = 120;
byte c = a + b; // Error

பொதுவாக, 8-பிட் (1 பைட்) எண்ணை 8-பிட் (1 பைட்) எண்ணால் பெருக்கும்போது, ​​16-பிட் பிட்களை (2 பைட்டுகள்) ஆக்கிரமித்திருக்கும் எண்ணைப் பெறுகிறோம்.

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

எடுத்துக்காட்டுகள்:

byte a = 110;
byte b = 120;
byte c = (byte) (a * b);

byte a = 110;
byte b = 120;
byte c = (byte) (a + b);

byte a = 1;
byte b = (byte) (a + 1);

5. ஒரு முக்கியமான நுணுக்கம்

தட்டச்சு இயக்குனருக்கு அதிக முன்னுரிமை உள்ளது.

அதாவது ஒரு எக்ஸ்ப்ரெஷன், எடுத்துக்காட்டாக, கூட்டல் மற்றும் டைப்காஸ்ட் ஆபரேட்டரைக் கொண்டிருந்தால், கூட்டலுக்கு முன் டைப்காஸ்ட் செய்யப்படும்.

உதாரணமாக:

byte a = 1;
byte b = 2;
byte c = (byte) a * b;

byte a = 1;
byte b = 2;
byte c = (byte) (a * b);

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