எண் (முழு எண், நீளம், பைட்)

"டெவலப்பர்கள் எண்களை விவரிக்கும் வகுப்புகளைக் கொண்டு வர முடியும் என்பதால், அவர்கள் உண்மையான டெவலப்பர்களைப் போலவே ஆக்கப்பூர்வமாக இருக்க முடிவு செய்தனர்."

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

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

"சரி. எப்படியிருந்தாலும், இதை நீங்கள் எழுத முடியாது:"

Long x = 100000;
Integer y = (Integer) x;

"ஆம், இந்த வகைகள் பழமையானவை அல்ல. அதனால்தான் நாங்கள் எண் வகுப்பின் முறைகளைப் பயன்படுத்துகிறோம்:"

Long x = 100000;
Integer y = x.intValue();

"ஆனால் இன்னும் கருத்தில் கொள்ள வேண்டிய விஷயங்கள் உள்ளன. முழு எண் ஒரு முழு எண்ணாக இல்லாததால், முழு எண் பொருள்களை கிளாசிக் «==» ஆபரேட்டருடன் ஒப்பிட முடியாது."

int x = 500;
int y = 500;
x == y; //true

Integer x = 500;
Integer y = 500;
x == y; //false
x.equals(y); //true

"சரியாக. எப்படியோ நான் அதை உடனடியாக நினைக்கவில்லை."

"ஆனால் இன்னும் இருக்கிறது."

"நீ என் சர்க்யூட்ஸை ஷார்ட் பண்ணுகிறாய்! வேறு என்ன இருக்கிறது?"

"ஒரு முழு எண் மாறிக்கு நாம் ஒரு முழு மதிப்பை ஒதுக்கும்போது, ​​Integer.valueOf முறை அழைக்கப்படுகிறது:"

Integer x = 5;

Integer x = Integer.valueOf(5);

"ஆம், மேலே உள்ள உதாரணத்திலிருந்து நான் ஏற்கனவே புரிந்துகொண்டேன்."

"ஆனால், செயல்பாட்டின் மதிப்பு எப்போதும் ஒரு புதிய முழு எண் பொருளை உருவாக்காது."

"ஓ, "எப்போதும் இல்லை" என்று நீங்கள் என்ன சொல்கிறீர்கள்?"

"இது -128 முதல் 127 வரையிலான மதிப்புகளை தேக்குகிறது."

Integer x = 300;
Integer y = 300;
Integer z = 300;

Integer x = Integer.valueOf(300);
Integer y = Integer.valueOf(300);
Integer z = Integer.valueOf(300);

Integer x = 100;
Integer y = 100;
Integer z = 100;

Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
Integer z = Integer.valueOf(100);

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = 10;
Integer t = 10;

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = Integer.valueOf(10);
Integer t = Integer.valueOf(10);

"வேறுவிதமாகக் கூறினால், நிலைமை இதுதான்:"

1)  "புதிய முழு எண்()" என்று எழுதினால், ஒரு புதிய பொருளைப் பெறுவது உறுதி.

2)  Integer.valueOf(), வெளிப்படையாகவோ அல்லது autoboxing மூலமாகவோ அழைத்தால், எண் வாதம் -128 முதல் 127 வரையிலான வரம்பில் இருந்தால், முறை ஒரு புதிய பொருளையோ அல்லது தற்காலிக சேமிப்பில் உள்ள பொருளையோ திருப்பி அனுப்பலாம்.

"தேக்ககத்திலிருந்து ஒரு பொருளைத் திரும்பப்பெறும் முறையில் என்ன கொடுமை?"

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

int x = 300;
Integer y = 300;
Integer z = 300;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references)

int x = 100;
Integer y = 100;
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //true (comparison based on references; they point to the same object)

int x = 100;
Integer y = new Integer(100);
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references; they point to different objects)

"அருமை... இதையெல்லாம் நான் எப்படி மனப்பாடம் பண்ணுவேன்?"

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

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

"ஆம், எனக்கு நினைவிருக்கிறது. Integer.parseInt();"