---
title: Überlaufe
url: 'https://tutego.de/blog/javainsel/2012/06/berlaufe'
markdown: 'https://tutego.de/blog/javainsel/2012/06/berlaufe.md'
date: '2012-06-16'
description: 'Bei einigen mathematischen Fragestellungen muss sich feststellen lassen, ob Operationen wie die Addition, Subtraktion oder Multiplikation den Zahlenbereich sprengen, also etwa den Ganzzahlenbereich eines Integers von 32 Bit verlassen. Passt das Ergebnis einer Berechnung nicht in den Wertebereich ei…'
taxonomy:
  category:
    - Insel
    - 'Java 8'
---

# Überlaufe

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Überlaufe

16.06.2012 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

Bei einigen mathematischen Fragestellungen muss sich feststellen lassen, ob Operationen wie die Addition, Subtraktion oder Multiplikation den Zahlenbereich sprengen, also etwa den Ganzzahlenbereich eines Integers von 32 Bit verlassen. Passt das Ergebnis einer Berechnung nicht in den Wertebereich einer Zahl, so wird dieser Fehler standardmäßig nicht von Java angezeigt; weder der Compiler noch die Laufzeitumgebung melden dieses Problem. Es gibt auch keine Ausnahme, Java hat keine eingebaute Überlaufkontrolle.

Beispiel

Mathematisch gilt a × a / a = a, also zum Beispiel 100 000 × 100 000 / 100 000 = 100 000. In Java ist das anders, da wir bei 100 000 × 100 000 einen Überlauf im int haben.

```java
System.out.println( 100000 * 100000 / 100000 ); // 14100
```

liefert daher 14100. Wenn wir den Datentyp auf long erhöhen, indem wir hinter ein 100 000 ein L setzen, sind wir bei dieser Multiplikation noch sicher, da ein long das Ergebnis aufnehmen kann.

```java
System.out.println( 100000L * 100000 / 100000 ); // 100000
```

Hinweis

Ein Test auf Überlauf könnte aussehen: boolean `canMultiply(int a, int b)` { return a \* b / b == a; } reichen. Doch eine JVM kann das zu return a == a; optimieren und somit zu return `true`; machen, sodass der Test nicht funktioniert.

###### Überlauf erkennen

Für eine Operation wie die Addition oder Subtraktion lässt sich relativ leicht erkennen, ob das Ergebnis über das Ziel hinausschießt. Eine Möglichkeit ist, bei der Addition zweier ints diese erst auf long zu bringen und dann den long mit der Konstanten `Integer`.MAX\_VALUE/Integer.MIN\_VALUE zu vergleichen. Aber über die Interna brauchen wir uns keine großen Gedanken machen, denn ab Java 8 kommen neue Methoden hinzu, die eine Überlauferkennung ermöglichen. Die Methoden gibt es in Math und StrictMath:

```java
· static int addExact(int x, int y)
```

- `static long addExact(long x, long y)`

```java
· static int subtractExact(int x, int y)
```

- `static long subtractExact(long x, long y)`

```java
· static int multiplyExact(int x, int y)
```

- `static long multiplyExact(long x, long y)`

```java
· static int toIntExact(long value)
```

Alle Methoden werfen eine `ArithmeticException`, falls die Operation nicht durchführbar ist, die letzte, wenn (int)value != value ist. Leider deklariert Java keine Unterklassen wie `UnderflowException` oder `OverflowException`, und Java meldet nur alles vom Typ `ArithmeticException` mit der Fehlermeldung „xxx overflow“, auch wenn es eigentlich ein Unterlauf ist:

```java
System.out.println( subtractExact( Integer.MIN_VALUE, 1 ) ); // ArithmeticException
```

Kategorien: [Insel](https://tutego.de/blog/javainsel/category/insel/), [Java 8](https://tutego.de/blog/javainsel/category/java-8/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Inselupdate: Vorzeichenlos arbeiten](https://tutego.de/blog/javainsel/2012/06/inselupdate-vorzeichenlos-arbeiten.md)
- Next: [Besondere Rückgaben oder Ausnahmen?](https://tutego.de/blog/javainsel/2012/06/besondere-rckgaben-oder-ausnahmen.md)
