Getal (geheel getal, lang, byte)

"Omdat ontwikkelaars klassen konden bedenken die getallen beschrijven, besloten ze creatief te zijn, net als echte ontwikkelaars."

"Eerst bedachten ze een abstracte Number-klasse, waarvan Byte, Short, Integer, Long, Float en Double zijn afgeleid. Het heeft methoden die helpen bij het converteren van getallen naar andere numerieke typen."

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

"Juist. Dit kun je tenslotte niet schrijven:"

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

"Ja, deze typen zijn geen primitieven. Daarom gebruiken we de methoden van de klasse Number:"

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

"Maar er zijn nog een paar dingen om rekening mee te houden. Omdat Integer geen int is, kunnen Integer-objecten niet worden vergeleken met de klassieke «==»-operator."

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

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

'Precies. Op de een of andere manier dacht ik daar niet meteen aan.'

"Maar er is meer."

'Je sluit mijn circuits kort! Wat is er nog meer?'

"Als we een int-waarde toekennen aan een Integer-variabele, wordt de Integer.valueOf-methode genoemd:"

Integer x = 5;

Integer x = Integer.valueOf(5);

"Ja, dat begreep ik al uit bovenstaand voorbeeld."

"Maar de functie valueOf maakt niet altijd een nieuw Integer-object aan."

"Uh, wat bedoel je met "niet altijd"?"

"Het cachet waarden van -128 tot 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);

"Met andere woorden, de situatie is deze:"

1)  Als we «new Integer()» schrijven, krijgen we gegarandeerd een nieuw object.

2)  Als we Integer.valueOf() aanroepen, expliciet of via autoboxing, dan kan de methode een nieuw object of een object in de cache retourneren als het getalargument in het bereik van -128 tot 127 ligt.

"Wat is er zo verschrikkelijk aan de methode die een object uit de cache terugstuurt?"

"Laat maar. Je moet alleen weten dat objecten soms, als je het niet verwacht, gelijk kunnen zijn. Alles met gelijkheid is gecompliceerd. Als we een primitief vergelijken met een niet-primitief, dan worden ze vergeleken als primitieven:"

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)

"Geweldig... En hoe ga ik dit allemaal onthouden?"

"Je hoeft dit niet uit je hoofd te leren. Je hoeft alleen maar te begrijpen hoe dit allemaal is georganiseerd en wat er werkelijk gebeurt als een primitieve en zijn niet-primitieve tegenhanger in het spel komen."

"Ik raad je ook aan om naar de methoden van de Integer-klasse te kijken. Die heeft nogal wat goede en bruikbare methoden. Je hebt er zelfs al heel vaak een gebruikt."

"Ja, ik herinner het me. Integer.parseInt();"