BlueJ Debugger

Der in BlueJ integrierte Debugger stellt ein leistungsfähiges Tool bei der Fehlersuche im eigenen Projekt dar. Es hat sich herausgestellt, dass der Debugger bewusst einfach in der Handhabung sein soll, so dass er innerhalb kürzester Zeit sinnvoll erlernt und eingesetzt werden kann. Um den Umfang nicht zu sprengen, ist die Funktionalität des Debuggers auf drei Dinge reduziert worden. Es können Breakpoints gesetzt und der Programmcode Schritt für Schritt abgearbeitet werden und gleichzeitig ist ein Überblick über alle Variablen ständig gewährleistet.

Um die Vorgehensweise bei der Arbeit mit dem Debugger zu erläutern, habe ich eine einfache Klasse geschrieben, welche einige Variablen mit Werten füllt und dann einige Berechnungen ausführt. Hier der Quellcode:

/**
 * Klasse Demonstration01.
 * 
 * @author Yves Schumann
 * @version 1.0
 */

public class Demonstration01
{
   // instance variables - replace the example below with your own
   private static int variable_static_1;
   private int variable_instance_1;
      
        /**
         * Konstruktor für Objekte der Klasse Demonstration01
         */
        public Demonstration01()
        {
        // initialise instance variables
        variable_static_1 = 0;
        }

        /**
         * Beispielmethode, Ausgabe einiger Zeile Text mittels For-Schleife
         */
        public void writeSomething()
        {
                int variable_local_1 = 1;             // Lokale Variable anlegen und initialisieren
                variable_static_1 = 1;                 // Statische Variable initialisieren
                variable_instance_1 = 1;            // Instance Variable initialisieren
                System.out.println("\nJetzt wollen wir mal einige Zeilen ausgeben!");
                System.out.println("Inhalt der lokalen Variable zu Beginn: "+variable_local_1);
                for (int i=1; i<11; i++){
                        System.out.println(i+". Durchlauf: ");
                        variable_local_1 += variable_local_1;
                        System.out.println("Inhalt der lokalen Variable: "+variable_local_1);
                }
        System.out.println("\nEnde der Ausgabe. \n");
        }
}

Um den Debugger zu starten, muss man einen Braekpoint am gewünschten Abschnitt des Quellcodes setzen. Dazu befindet sich im Editor links neben dem Code der Breakpoint-Bereich. Durch einen Linksklick in diesen Bereich und auf Höhe der gewünschten Code-Zeile, wird hier ein Breakpoint gesetzt. Breakpoints können nur auf Codezeilen gesetzt werden, nicht aber auf Komentarzeilen oder Variablenvereinbarungen, insofern diese nur vereinbart, nicht aber initialisiert werden. Dies lässt sich einfach nachvollziehen. In allen Zeile die mit den Komentarsymbolen beginnen lassen sich keine Breakpoints setzten, ebenso nicht auf Klassen- oder Methodennamen.

Um den Debugger zu testen, sollte nun die Beispielklasse in den Editor kopiert werden. Alternativ kann diese auch hier heruntergeladen werden. Jetzt soll ein Breakpoint gesetzt werden. Dazu nach dem Kompilieren in der Methode writeSomething() in der Zeile 29 auf den Breakpoint-Bereich klicken. Hier ist nun ein Stop-Icon zu sehen. An dieser Stelle wird die Abarbeitung des Programmes gestoppt und der Debugger eingeblendet. Das Editor-Fenster sollte nun in etwa so aussehen:

Nun kann die Methode writeSomething() ausgeführt werden. Es öffnet sich das Debugger-Fenster und im Editor wird an der aktuellen Stelle der Abarbeitung des Codes ein Pfeil eingeblendet. Die Zeile auf der sich der Pfeil befindet, ist die als nächste abzuarbeitende Zeile, sie ist also noch nicht ausgeführt worden.

Die statische sowie die lokale Variable ist zu diesem Zeitpunkt bereits initialisiert worden. Im nun folgenden Schritt wird die Instanzvariable mit dem Wert eins beschrieben. Dazu auf den Button "Step" klicken, so das der Programmablauf einen Schritt weiter rückt. Mit jedem weiteren Klick wird das Programm nun Schritt für Schritt abgearbeitet. Somit ist nach jedem Klick zu sehen, welche Codezeile abgearbeitet wurde und wie sich dies auf die Variablen ausgewirkt hat. Nach einigen Klicks kann der Inhalt der Variablen z. B. so aussehen und der Programmcounter an folgender Stelle stehen:

Der Aufruf von anderen Methoden wird durch den Button "Step" als ein Schritt angesehen. Um eine aufgerufene Methode Schritt für Schritt abzuarbeiten kann der Button "Step Into" benutzt werden. Wie der Name schon sagt springt man damit in eine Methode hinein.

Es können beliebig viele Breakpoints gesetzt werden. Da es allerdings viel zu aufwendig ist, immer alles Step by Step ablaufen zu lassen, kann mit dem Button "Continue" der Programmablauf bis zum nächsten Breakpoint oder auch zum Programmende fortgesetzt werden. "Halt" wird nur während der wirklich im Moment ablaufenden Bearbeitung anklickbar. Damit kann ein momentaner Vorgang angehalten und wieder fortgesetzt werden. Somit kann z. B. eine Endlosschleife ausfindig gemacht werden. Ein lange laufender Vorgang kann einfach unterbrochen werden, es können einige Steps "von Hand" zum Checken der Variablen durchgeführt werden und mit "Continue" lässt sich die Abarbeitung dann fortsetzen. Durch "Terminate" kann eine ablaufende Methode sprichwörtlich terminiert werden.

Noch einige Erläuterungen zum Debuggerfenster selbst. Im oberen Teil werden die laufenden Threads angezeigt, unten links ist die rufende Methode zu sehen. Für die Variablen sind drei einzelne Abschnitte vorgesehen, für die statischen, die lokalen sowie die Instanzvariablen.