# Overflows in Java



## snafu (25. Jan 2004)

Hi Leute,


```
class Overflow { 
     public static void main (String[] args) { 
         int big =  0x7FFFFFFF; 
        System.out.println("big = "+big); 
        int bigger = big * 4; 
        System.out.println("bigger = "+bigger); 
     } 
}
```

Dieses kleine Programm erzeugt einen Overflow. Fängt Java nicht eigentlich Overflows ab?
Das Programm findet ihr in dem Buch Thinking in Java von Bruce Eckel (www.bruceeckel.com)
(Sollte man sich eigentlich mal angucken)

Interessant finde ich die Art, wie Java mit Ganzzahlen umgeht und damit rechnet, ich habe herrausgefunden, dass
Java einen overflow nur bei einer Rechnung mit Integer-Werten zulässt. Der Grund dafür ist, dass 
Java bei einer Rechnung zweier Integer-Typen (byte, short, int, long) von einer Integer Operation ausgeht.



> If all of the operands of an operator are of an integer type, the operation is performed as an integer operation. Normally, integer operations are performed with a precision of 32 bits. If at least one of the operands of an integer operation is a long, however, the operation is performed with a precision of 64 bits.
> 
> When an integer operation overflows or underflows, there is no indication given that the overflow or underflow occurred.
> 
> _Aus Java Language Reference von O'Reilly_



Das bedeutet, doch aber, das Java wenn der Wert für eine 32-bit Integervariable zu hoch ist, einen long für das
Ergebnis verlangen müsste, aber wieso macht er das hier nicht?

Schreibt man ein ähnliches Programm mit shortvariabeln, dann verlangt Java für das Ergebnis ein Int.

Folgender Quelltext zeigt das:


```
class Overflow { 
     public static void main (String[] args) { 
        short big = 32767; 
        short bigger = big*4; 
        System.out.println("bigger = "+bigger); 
     } 
}
```

Dieses Programm kann nicht compiliert werden und erzeugt folgenden Fehler:



> overflow.java [4:1] possible loss of precision
> found   : int
> required: short
> short bigger = verybig*4;
> ...


Das beweist demnach die These, das Java bei Rechnungen von einer Int-Operation ausgeht, man könnte das Ergebnis falls nicht zu groß, also in short- oder bytewerte casten.

Seltsam finde ich auch, dass ein Programm sich nicht compilieren lässt, wenn man einer Longvariable ihren maximalen Wert zuweist. Dann bekommt man die Fehlermeldung: Integer number too long.


Kann es sein, das Java bei Ganzzahlen auch in Zuweisungen von Integerwerten ausgeht?


gruß krenke


----------



## Stefan1200 (26. Jan 2004)

Welches Java RE benutzt du denn?
Ich glaube mich daran zu erinnern, das Sun auch mal Overflow Probleme hatte, und dieses in den neueren 1.4.1 und 1.4.2 Versionen gefixt hat (glaube ab 1.4.1_03 und 1.4.2_01).
Ich weiss jetzt aber nicht, ob dass das gleiche ist.


----------



## jptc.org (26. Jan 2004)

das Verhalten bei byte, short, (char) ist relativ einfach nachzuvollziehen. denn rechenoperationen mit diesen typen werden immer als int ausgeführt, d.h. intern gibt es kein byte oder short. ein schönes beispiel ist:


```
byte a=2;
byte b=3;
byte c = a + b;
```

tja der sourcecode sieht sauber aus funktioniert aber nicht und man bekommt _Type mismatch: cannot convert from int to byte_. da hilft nur:


```
byte a=2;
byte b=3;
byte c = (byte) a + b;
```

Karsten Voigt
http://www.java-performance-portal.org


----------



## snafu (26. Jan 2004)

> Welches Java RE benutzt du denn?



Ich benutze das neuste. Der Overflow kann mit jeder Java-Version erzeugt werden. Eben weil bei Rechnungen von Integer Operationen ausgegangen wird.

Mich wundert nur, dass auch einer Longvariable nur den maximalen Integerwert zuweisen kann.


----------

