Zwei Zahlen in Java addieren

Zwei Zahlen zu addieren ist die erste Rechenoperation, die die meisten Menschen in Java schreiben. Der „richtige" Weg hängt jedoch davon ab, woher die Zahlen stammen und wie groß sie werden können. Dieses Kapitel behandelt die idiomatischen Ansätze: einfache int-Arithmetik, das Parsen von Textwerten, Gleitkommaaddition und sicheres Addieren ohne stillen Überlauf.

Zwei int-Werte addieren

Der einfachste Fall ist das Addieren zweier int-Variablen mit dem +-Operator, einem der arithmetischen Operatoren von Java. Das Ergebnis ist selbst ein int.

int a = 7;
int b = 5;
int sum = a + b;
System.out.println(sum); // 12

Dies ist der alltägliche Fall und der, den man am häufigsten schreibt. Zu beachten ist lediglich der Wertebereich von int: Er reicht von -2.147.483.648 bis 2.147.483.647. Wird dieser Grenzwert überschritten, läuft der Wert stillschweigend um, anstatt eine Ausnahme auszulösen – dazu weiter unten mehr.

Zahlen aus Text parsen und addieren

Wenn die Zahlen als Strings ankommen – aus Konsoleneingaben, einer Datei oder einer HTTP-Anfrage – müssen sie vor der Addition konvertiert werden. Verwende Integer.parseInt für ganze Zahlen oder Double.parseDouble für Dezimalzahlen.

String first = "42";
String second = "58";
int sum = Integer.parseInt(first) + Integer.parseInt(second);
System.out.println(sum); // 100

Ein häufiger Anfängerfehler ist die direkte Verwendung von + auf den Strings: "42" + "58" ergibt "4258", da + Strings verkettet statt sie zu addieren. Zuerst parsen, dann addieren. Wenn der Text keine gültige Zahl ist, wirft parseInt eine NumberFormatException – bei nicht vertrauenswürdiger Eingabe also validieren oder den Aufruf in ein try/catch einwickeln.

Dezimalzahlen addieren und Überlauf behandeln

Für Dezimalwerte addiert man double- (oder float-) Operanden. Zu beachten ist, dass binäre Gleitkommazahlen nicht jede Dezimalzahl exakt darstellen können: 0.1 + 0.2 ergibt 0.30000000000000004 und nicht 0.3. Für Geldbeträge sollte stattdessen BigDecimal verwendet werden.

Für ganze Zahlen, die den int-Bereich überschreiten können, einen Operanden auf long erweitern oder Math.addExact verwenden, um bei Überlauf eine Ausnahme statt eines falschen Ergebnisses zu erhalten. Den richtigen numerischen Typ von vornherein zu wählen, ist die sauberste Lösung – die Wertebereiche der einzelnen Typen sind unter Java-Datentypen beschrieben.

int big = Integer.MAX_VALUE;
System.out.println(big + 1);               // -2147483648 (wrapped!)
System.out.println((long) big + 1);        // 2147483648 (correct)
System.out.println(Math.addExact(big, 1)); // throws ArithmeticException

Zwei vom Benutzer eingegebene Zahlen addieren

In einem echten Programm stammen die Operanden oft von der Tastatur. Ein Scanner liest jede Zeile und konvertiert sie in einem Schritt mit nextInt (oder nextDouble für Dezimalzahlen) in eine Zahl, sodass parseInt nicht manuell aufgerufen werden muss.

import java.util.Scanner;

public class AddInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = scanner.nextInt();
        System.out.print("Enter second number: ");
        int b = scanner.nextInt();
        System.out.println("Sum: " + (a + b));
    }
}

Gibt der Benutzer etwas ein, das keine ganze Zahl ist, wirft nextInt eine InputMismatchException. Bei nicht vertrauenswürdiger Eingabe dagegen mit hasNextInt() oder einem try/catch absichern.

Ein vollständiges Beispiel

Was die Ausgabe zeigt:

• int sum: 12 zeigt den einfachen +-Operator, der zwei int-Werte direkt addiert – der Alltagsfall.
• parsed sum: 100 bestätigt, dass Integer.parseInt aus "42" und "58" Zahlen macht, bevor sie addiert werden, statt sie zu "4258" zu verketten.
• double sum: 0.30000000000000004 ist der Gleitkommadarstellungsfehler von 0.1 + 0.2 – Beweis dafür, dass double bei Dezimalzahlen nicht exakt ist; für präzise Berechnungen sollte BigDecimal verwendet werden.
• int overflow: -2147483648 zeigt, wie Integer.MAX_VALUE + 1 stillschweigend zum kleinsten negativen int umläuft, während long safe: 2147483648 das richtige Ergebnis liefert, indem ein Operand auf long erweitert wird.
• addExact: overflow detected bestätigt, dass Math.addExact bei demselben Überlauf eine ArithmeticException wirft, statt einen falschen Wert zurückzugeben.

Übungsaufgaben