Debug in IntelliJ IDEA

1. Bug

Programmierer haben ihren eigenen Slang. Und das erste Wort, mit dem du intensiv in Berührung kommst, ist Bug (Käfer). Dieses Wort bezeichnet einen Fehler im Programm, der dazu führt, dass es etwas Unerwartetes tut, abstürzt oder ein seltsames Ergebnis liefert.

Wenn ein Programm seltsam funktioniert, der Programmierer aber versichert, dass dies so gewollt war, sagt man oft: „Das ist kein Bug, das ist ein Feature“. Das Internet ist voll von Memes zu diesem Thema.

Historischer Hintergrund

Die Legende besagt, dass Wissenschaftler in Harvard im September 1947 den Computer Mark II testeten. Er funktionierte nicht richtig. Nachdem sie alle Kontakte überprüft hatten, fanden sie eine echte Motte, die zwischen den Relais feststeckte. Das Insekt wurde mit der Bildunterschrift „First actual case of bug being found“ (Erster tatsächlicher Fall eines gefundenen Käfers) in das Logbuch geklebt.

Seitdem wird der Prozess des Findens und Behebens von Fehlern als Debug oder Debugging bezeichnet.

---

2. Debug Mode

Um einen Fehler zu finden, verwenden Programmierer einen Debugger. Das ist ein spezielles Werkzeug in IntelliJ IDEA, mit dem man die Programmausführung pausieren und „unter die Haube“ schauen kann.

IntelliJ IDEA kann dein Programm in zwei Modi ausführen:

Im Debug-Modus kannst du das Programm zeilenweise ausführen und beobachten, wie sich die Werte der Variablen ändern.

3. Breakpoints (Haltepunkte)

Damit der Debugger weiß, wo er anhalten soll, musst du einen Breakpoint setzen. Ohne ihn läuft das Programm wie gewohnt bis zum Ende durch.

Lass uns an einem praktischen Beispiel üben. Wir haben die Multiplikationslogik in eine separate Methode ausgelagert, um die ganze Leistungsfähigkeit des Debuggers zu zeigen. Kopiere diesen Code in IDEA:

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int result = calculateMultiply(i);  // <--- Hier wollen wir anhalten
            sum += result;
            System.out.println("Step: " + i + ", Result: " + result + ", Sum: " + sum);
        }
        System.out.println("Final Sum: " + sum);
    }

    public static int calculateMultiply(int number) {
        return number * 2;
    }
}

Aufgabe. Wir wollen sehen, wie sich die Variablen innerhalb der Schleife verändern, und einen Blick in unsere Methode werfen.

Aktion. Klicke mit der Maus auf den schmalen grauen Streifen links neben der Zeile int result = calculateMultiply(i);. Ein roter Kreis wird erscheinen.

Starte nun das Programm über Debug (das Käfer-Icon). Das Programm startet und „friert“ sofort vor der Ausführung dieser Zeile ein.

4. Steuerung: F8, F7, F9

Wenn das Programm pausiert ist, hast du ein Bedienfeld im oberen Teil des Debugger-Panels.

F8 — Step Over (Überspringen)

Drücke F8. Das Programm führt die aktuelle Zeile aus (ruft die Methode auf, holt das Ergebnis) und geht zur nächsten über: sum += result;.

Drücke nochmals F8. Das Programm addiert die Zahlen. Du wirst sehen, wie sich die Variablenwerte geändert haben.

Drücke nochmals F8. Du siehst die Ausgabe in der Konsole.

Dies ist die grundlegende Art der Navigation: Zeile für Zeile, ohne in die internen Details von Methoden einzutauchen.

F9 — Resume Program (Fortsetzen)

Wir haben eine Schleife von 1 bis 5. Fünfmal F8 zu drücken, um einen Schleifendurchlauf zu machen, dauert lange. Und was ist, wenn die Schleife 1000 Iterationen hat?

Drücke F9. Das Programm läuft weiter, führt den gesamten restlichen Code der aktuellen Iteration aus, geht in die nächste Runde und... stoppt wieder am Breakpoint.

Auf diese Weise kannst du mit F9 schnell durch Schleifen springen: ein Druck — eine Iteration.

F7 — Step Into (Hineinspringen)

Wenn im Code ein Aufruf deiner Methode vorkommt (in unserem Fall calculateMultiply(i)) und du F8 drückst, führt der Debugger sie einfach aus und geht weiter. Wenn du aber sehen willst, wie der Code innerhalb dieser Methode funktioniert — drücke F7.

Versuche F7 zu drücken, wenn das Programm in der Zeile int result = calculateMultiply(i); anhält. Der Debugger bringt dich in die Methode calculateMultiply und du siehst, wie der Wert an den Parameter number übergeben wird.

Shift + F8 — Step Out (Herausspringen)

Was tun, wenn du versehentlich F7 in der Zeile System.out.println(...) gedrückt hast und im Dickicht des Java-Systemcodes gelandet bist? Tausende Zeilen fremden Codes zu lesen, ist langweilig und unverständlich.

Drücke Shift + F8. Das Programm führt den restlichen Code der aktuellen Methode schnell aus und bringt dich dorthin zurück, wo du hergekommen bist (in deine main-Methode).

5. Wo sieht man die Werte?

Kommen wir zurück zu unserem Schleifenbeispiel.

Methode 1: Inline Debugging

Schau direkt in den Code-Editor. Rechts neben den Zeilen schreibt IDEA die aktuellen Werte in Grau.

Methode 2: Das Variables-Panel

Unten im Debugger-Fenster gibt es den Tab Variables. Dort werden alle aktuellen Variablen angezeigt.

Wichtiger Hinweis für Java: Primitive Datentypen (z. B. int) zeigen ihren Wert sofort an. Objekte und Arrays (z. B. String[]) speichern jedoch viele Daten in sich. Um ihren Inhalt zu sehen, musst du auf den kleinen Pfeil links neben der Variablen klicken, um das Objekt „aufzuklappen“.

Methode 3: Das Frames-Panel

Links neben den Variablen befindet sich eine Liste namens Frames (Call Stack). Sie zeigt an, bei welchem Schritt sich das Programm gerade befindet.

Zum Beispiel bedeutet der Eintrag main:6, Main:

• Du befindest dich in der main-Methode der Klasse Main.
• Du hast in Zeile 6 angehalten.

Das ist deine genaue Adresse im Code. Wenn du in eine andere Methode abtauchst (F7 bei calculateMultiply drückst), erscheint in dieser Liste oben ein neuer Eintrag calculateMultiply:13, Main, was darauf hinweist, dass die neue Methode aus der vorherigen aufgerufen wurde.

6. Evaluate Expression

Manchmal reicht es nicht, nur auf die Variablen zu schauen. Man möchte fragen: „Was wäre, wenn...“

Drücke Alt + F8 (Windows/Linux) oder Option + F8 (macOS). Das „Evaluate“-Fenster öffnet sich. Du kannst Ausdrücke auch direkt in die Zeile unter dem Variables-Panel eingeben.

Hier kannst du beliebigen Code unter Verwendung der aktuellen Variablen schreiben. Schreibe in unserer Schleife zum Beispiel:

sum + 100

Drücke Enter und IDEA berechnet das Ergebnis, ohne das eigentliche Programm zu verändern. Dies ist dein Entwurf für Experimente.

7. Conditional Breakpoints

Stell dir vor, du hast eine Schleife mit 10.000 Iterationen und der Fehler tritt erst beim 5000. Schritt auf. Fünftausendmal F9 zu drücken, ist eine schlechte Idee.

Klicke mit der rechten Maustaste auf den roten Breakpoint-Kreis. Ein Popup-Fenster erscheint. Schreibe in das Feld Condition eine Java-Bedingung, zum Beispiel: i == 5. Klicke auf Done.

Wenn du nun den Debugger startest, ignoriert das Programm die ersten 4999 Runden und hält erst an, wenn die Bedingung true wird. Das spart dir Stunden an Arbeit!

8. Alle Breakpoints verwalten

Manchmal setzen Anfänger so viele Breakpoints in verschiedenen Projektdateien, dass das Programm später ständig an unerwarteten Stellen anhält. Rote Kreise manuell in allen Dateien zu suchen, dauert lange.

Drücke Ctrl + Shift + F8 (Windows/Linux) oder Cmd + Shift + F8 (macOS). Das Fenster Breakpoints öffnet sich.

Hier siehst du eine Liste aller Breakpoints in deinem Projekt. Du kannst die Häkchen entfernen (vorübergehend deaktivieren) oder sie mit der Delete-Taste löschen.

9. Fazit

Wir haben das grundlegende Arsenal eines Java-Entwicklers zur Fehlersuche betrachtet. Der Debugger ist das, was das Schreiben von Code vom „Kaffeesatzlesen“ in präzise Ingenieursarbeit verwandelt.

Die Fähigkeit, die Ursache eines Fehlers schnell zu finden, ist eine Fähigkeit, die in der kommerziellen Entwicklung noch mehr geschätzt wird als die Fähigkeit, schnell Code zu schreiben. Übe mit bedingten Breakpoints und Evaluation, und kein Bug wird sich vor dir verstecken können.