Zahl (Ganzzahl, Lang, Byte)

„Da Entwickler Klassen entwickeln konnten, die Zahlen beschreiben, beschlossen sie, kreativ zu sein, wie echte Entwickler.“

„Zuerst haben sie eine abstrakte Zahlenklasse entwickelt, von der Byte, Short, Integer, Long, Float und Double abgeleitet sind. Sie verfügt über Methoden, die dabei helfen, Zahlen in andere numerische Typen umzuwandeln.“

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

„Richtig. Das kann man schließlich nicht schreiben:“

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

„Ja, diese Typen sind keine Primitive. Deshalb verwenden wir die Methoden der Number-Klasse:“

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

„Aber es gibt noch ein paar Dinge zu beachten. Da Integer kein Int ist, können Integer-Objekte nicht mit dem klassischen «==»-Operator verglichen werden.“

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

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

„Genau. Irgendwie ist mir das nicht sofort eingefallen.“

„Aber da ist noch mehr.“

„Sie schließen meine Stromkreise kurz! Was gibt es sonst noch?“

„Wenn wir einer Integer-Variablen einen int-Wert zuweisen, wird die Methode Integer.valueOf aufgerufen:“

Integer x = 5;

Integer x = Integer.valueOf(5);

„Ja, das habe ich aus dem Beispiel oben schon verstanden.“

„Aber die valueOf-Funktion erstellt nicht immer ein neues Integer-Objekt.“

„Äh, was meinst du mit ‚nicht immer‘?“

„Es speichert Werte von -128 bis 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);

„Mit anderen Worten, die Situation ist folgende:“

1)  Wenn wir „new Integer()“ schreiben, erhalten wir garantiert ein neues Objekt.

2)  Wenn wir Integer.valueOf() explizit oder durch Autoboxing aufrufen, gibt die Methode möglicherweise ein neues Objekt oder ein zwischengespeichertes Objekt zurück, wenn das Zahlenargument im Bereich von -128 bis 127 liegt.

„Was ist so schrecklich daran, dass die Methode ein Objekt aus dem Cache zurückgibt?“

„Macht nichts. Sie müssen nur wissen, dass Objekte manchmal, wenn Sie es nicht erwarten, gleich sein können. Alles mit Gleichheit ist kompliziert. Wenn wir ein Primitiv mit einem Nicht-Primitiv vergleichen, dann werden sie als Primitiv verglichen:“

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)

„Großartig... Und wie soll ich mir das alles merken?“

„Sie müssen sich das nicht merken. Sie müssen nur verstehen, wie das alles organisiert ist und was tatsächlich passiert, wenn ein Primitives und sein nicht-primitives Gegenstück ins Spiel kommen.“

„Ich empfehle Ihnen auch, sich die Methoden der Integer-Klasse anzusehen. Sie verfügt über einige gute und nützliche Methoden. Eine davon haben Sie sogar schon oft verwendet.“

„Ja, ich erinnere mich. Integer.parseInt();“