సంఖ్య (పూర్ణాంకం, పొడవు, బైట్)

"డెవలపర్లు సంఖ్యలను వివరించే తరగతులతో ముందుకు రావచ్చు కాబట్టి, వారు నిజమైన డెవలపర్‌ల వలె సృజనాత్మకంగా ఉండాలని నిర్ణయించుకున్నారు."

"మొదట, వారు బైట్, షార్ట్, పూర్ణాంకం, లాంగ్, ఫ్లోట్ మరియు డబుల్ అనే ఒక అబ్‌స్ట్రాక్ట్ నంబర్ క్లాస్‌తో ముందుకు వచ్చారు. ఇది సంఖ్యలను ఇతర సంఖ్యా రకాలుగా మార్చడంలో సహాయపడే పద్ధతులను కలిగి ఉంది."

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(), స్పష్టంగా లేదా ఆటోబాక్సింగ్ ద్వారా కాల్ చేస్తే, సంఖ్య ఆర్గ్యుమెంట్ -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();"