"Dahil ang mga developer ay maaaring makabuo ng mga klase na naglalarawan ng mga numero, nagpasya silang maging malikhain, tulad ng mga tunay na developer."

"Una, nakabuo sila ng abstract na klase ng Numero, kung saan nagmula ang Byte, Short, Integer, Long, Float, at Double. Mayroon itong mga pamamaraan na makakatulong sa pag-convert ng mga numero sa iba pang mga uri ng numeric."

Mga Paraan ng klase ng Numero
1
int intValue()
2
long longValue()
3
float floatValue()
4
double doubleValue()
5
byte byteValue()
6
short shortValue()

"Tama. Pagkatapos ng lahat, hindi mo ito maisusulat:"

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

"Oo, ang mga uri na ito ay hindi primitive. Iyon ang dahilan kung bakit ginagamit namin ang mga pamamaraan ng klase ng Numero:"

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

"Ngunit mayroon pa ring ilang bagay na dapat isaalang-alang. Dahil ang Integer ay hindi isang int, ang mga bagay na Integer ay hindi maikukumpara sa klasikong «==» operator."

Paghahambing ng mga primitive na uri
int x = 500;
int y = 500;
x == y; //true
Paghahambing ng mga hindi primitive na uri
Integer x = 500;
Integer y = 500;
x == y; //false
x.equals(y); //true

"Exactly. Kahit papaano hindi ko agad naisip yun."

"Pero meron pa."

"You're shorting my circuits! Ano pa bang meron?"

"Kapag nagtalaga kami ng int value sa isang Integer variable, ang Integer.valueOf method ay tinatawag na:"

Code Kung ano talaga ang nangyayari
Integer x = 5;
Integer x = Integer.valueOf(5);

"Oo, naiintindihan ko na iyon mula sa halimbawa sa itaas."

"Ngunit, ang valueOf function ay hindi palaging gumagawa ng bagong Integer object."

"Uh, anong ibig mong sabihin na «hindi palagi»?"

"Ini-cache nito ang mga halaga mula -128 hanggang 127."

Code Kung ano talaga ang nangyayari Paglalarawan
Integer x = 300;
Integer y = 300;
Integer z = 300;
Integer x = Integer.valueOf(300);
Integer y = Integer.valueOf(300);
Integer z = Integer.valueOf(300);
Ang variable na x, y, at z ay naglalaman ng mga sanggunian sa iba't ibang bagay
Integer x = 100;
Integer y = 100;
Integer z = 100;
Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
Integer z = Integer.valueOf(100);
Ang mga variable na x, y, at z ay naglalaman ng mga sanggunian sa parehong bagay.
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);
Ang mga variable na z at t ay naglalaman ng mga sanggunian sa parehong bagay.

"Sa madaling salita, ang sitwasyon ay ito:"

1)  Kung isusulat namin ang «new Integer()», garantisadong makakakuha kami ng bagong object.

2)  Kung tatawagin natin ang Integer.valueOf(), tahasan o sa pamamagitan ng autoboxing, kung gayon ang pamamaraan ay maaaring magbalik ng isang bagong bagay o isang naka-cache na bagay kung ang argumento ng numero ay nasa hanay mula -128 hanggang 127.

"Ano ang nakakatakot sa paraan ng pagbabalik ng isang bagay mula sa cache?"

"Hindi bale. Kailangan mo lang malaman na minsan, kapag hindi mo inaasahan, maaaring magkapantay ang mga bagay. Ang lahat ng bagay na may pagkakapantay-pantay ay kumplikado. Kung ihahambing natin ang isang primitive sa isang hindi primitive, kung gayon sila ay ikinukumpara bilang mga primitive:"

Problema sa paghahambing
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)
Isang mas kawili-wiling halimbawa. Ang cache ay pumapasok sa larawan dito
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)
Ngunit ang cache ay hindi kasangkot dito
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)

"Great... At paano ko kabisado ang lahat ng ito?"

"Hindi mo kailangang i-memorize ito. Kailangan mo lang maunawaan kung paano nakaayos ang lahat ng ito at kung ano talaga ang nangyayari kapag ang isang primitive at ang non-primitive na katapat nito ay naglaro."

"Inirerekomenda ko rin na tingnan mo ang mga pamamaraan ng klase ng Integer. Mayroon itong kaunting mahusay at kapaki-pakinabang na mga pamamaraan. Nagamit mo pa nga ang isa sa mga ito nang madalas."

"Oo, naalala ko. Integer.parseInt();"