Bevor Sie Ihre Programme veröffentlichen können, müssen Sie sie kompilieren, Fehler entfernen und die Logik austesten. Es gibt kein Entwicklungswerkzeug, das Ihnen garantiert, fehlerfreien Code zu produzieren, aber JBuilder stellt Ihnen Möglichkeiten bereit, mit denen Sie wenigstens versuchen können, auch den letzten Programmfehler zu finden.
Das Debugging ist eines der komplexeren Themen, deshalb wurde es auch bisher nicht besprochen. In diesem Abschnitt erfahren Sie, wie Sie mit Hilfe des in JBuilder integrierten Debuggers Ihre Java-Programme debuggen können. Außerdem werden Sie die verschiedenen Debugger-Ansichten kennenlernen, die in der IDE zur Verfügung stehen, und wie sie Ihnen helfen, fehlerfreien Code zu entwickeln.
Heute lernen Sie die folgenden Dinge kennen:
Um ein neues Projekt für die heutige Arbeit zu erzeugen, wählen Sie Datei | Neues Projekt und tragen folgendes in das Datei-Feld ein:
C:\JBUILDER\myprojects\CompileDebug.jpr
Klicken Sie auf die Schaltfläche Fertigstellen. Alle Listings für diese Lektion werden mit dem Icon Dem Projekt hinzufügen eingefügt, das sich oberhalb des Navigations-Bereichs im AppBrowser befindet.
Nachdem die Dateien Ihrer Anwendung erzeugt, die Benutzeroberfläche angepaßt und die Dateien gespeichert sind, können Sie kompilieren. In der IDE wird dies durch die Befehle Aktualisieren oder Neu erstellen bewerkstelligt. Sie können auch die Befehle im Popup-Menü des jeweils selektierten Knotens im AppBrowser verwenden. Wenn Sie beispielsweise im Navigations-Bereich einen .java-Knoten selektiert haben, zeigen Sie durch einen Klick mit der rechten Maustaste das in Abbildung 11.1 gezeigte Popup-Menü an.
Abbildung 11.1: Das Popup-Menü für eine .java.Datei im Navigations-Bereich
Diese Befehle stehen für die einzelnen selektierten Knoten im AppBrowser sowie auch für ganze Pakete und Projekte bereit. Der Dateiname und der Projektname werden den Menüelementen dynamisch hinzugefügt. Wenn beim Kompilieren keine Fehler auftreten, erscheint in der Statusleiste des Hauptfensters die Meldung Kompilierung erfolgreich.
Darüber hinaus führen die Befehle Start und Debug (beide stehen im Start-Menü und im Popup-Menü des Knotens zur Verfügung) eine implizite Aktualisierung durch, bevor sie versuchen, den selektierten Knoten auszuführen oder zu debuggen.
Der Menüeintrag Aktualisieren kompiliert alle Knoten, für die es noch keine .class-Datei gibt, oder deren .class-Datei älter als die Quelldatei ist. Dies wird auch als bedingte Compilierung bezeichnet.
Im Fall eines neuen Projekts kann jeder Aktualisieren-Befehl verwendet werden, weil noch überhaupt keine .class-Dateien erzeugt wurden. Normalerweise verwenden Sie jedoch den Aktualisieren-Befehl, um sicherzugehen, daß alle .class-Dateien für Ihr Projekt aktuell sind.
Durch Auswahl von Projekt | Projekt »ProjektName.jpr« weisen Sie die IDE an, eine bedingte Kompilierung (Make) für alle Quelldateien im aktuellen Projekt vorzunehmen. Durch Auswahl von Projekt | Aktualisieren »Dateiname.java« weisen Sie die IDE an, nur die aktuell selektierte Quelldatei zu kompilieren. Wenn es keine Quelldateien gibt, für die eine .class-Datei fehlt oder veraltet ist, erfolgt keine Kompilierung.
Die Auswahl eines Knotens und des Befehls Aktualisieren im Popup-Menü bewirkt eine bedingte Kompilierung dieses Knotens und aller davon abhängigen Quelldateien, wie etwa importierte Klassendateien oder Pakete.
Der Menüeintrag Neu erstellen kompiliert alle Ihre Projektdateien, unabhängig von ihrem Status; es erfolgt eine sogenannte unbedingte Kompilierung. Das Neu erstellen ist insbesondere dann sinnvoll, wenn Sie Ihre Anwendung fertiggestellt haben und das ganze Projekt ohne Debugging-Informationen neu kompilieren wollen.
Durch Auswahl von Projekt | Projekt »ProjektName.jpr« neu erstellen weisen Sie die IDE an, unbedingt alle Quelldateien des aktuellen Projekts zu kompilieren. Alternativ können Sie durch Auswahl von Projekt | »Dateiname.java« neu erstellen die IDE anweisen, nur die aktuell aktive Quelldatei zu kompilieren. Egal, in welchem Status sich die betreffenden .class-Dateien befinden, erfolgt in jedem Fall eine Kompilierung.
Dieser Befehl bewirkt außerdem, daß alle importierten Dateien und Pakete, für die Quellcode zur Verfügung steht, rekursiv kompiliert werden (außer den Paketen java und jbcl).
JBuilder bietet zahlreiche Compiler-Optionen, die Ihnen ermöglichen, zu steuern, wie Ihre ausführbaren Dateien erzeugt werden. Diese Optionen können entweder für alle Projekte als IDE-übergreifende Optionen gesetzt werden, oder für das aktuelle Projekt als projektspezifische Optionen. Sie können auch Optionen für Start- und Debug-Sitzungen festlegen, die Ihre Kompilierung beeinflussen, weil diese Befehle standardmäßig Aktualisieren aufrufen.
Wählen Sie bei geöffnetem Projekt Datei | Projekteigenschaften, um den Dialog Eigenschaften von Projektname.jpr anzuzeigen. Abbildung 11.2 zeigt den Dialog für das Projekt Welcome.
Abbildung 11.2: Projekteigenschaften für das Welcome-Projekt
In diesem Dialog können Sie Optionen setzen, die alle Dateien in Ihrem Projekt betreffen. Alle Dropdown-Listen in diesem Dialog zeigen zuvor eingestellte Werte an.
Die Pfade-Gruppe ent
Der Quellpfad gibt dem Compiler an, wo er nach den Quelldateien suchen soll, wenn Sie das Projekt kompilieren. Der Klassenpfad gibt an, wo der Compiler beim Aktualisieren nach .class-Dateien suchen soll, so daß er erkennt, welche Dateien kompiliert werden müssen. Der Compiler kann in mehreren Pfaden nach Quell- und .class-Dateien suchen, deshalb erlauben die Felder Quellpfad und Klassenpfad die Angabe mehrerer Pfadnamen, jeweils getrennt durch ein Semikolon.
Der Ausgabepfad gibt an, wo der Compiler die kompilierten .class-Dateien ablegen soll, wenn die Kompilierung erfolgreich war. Der Compiler kann die .class-Dateien nur in ein einziges Verzeichnis ausgeben, deshalb können Sie in dieses Kombinationsfeld nur einen einzigen Pfadnamen eingeben.
Die Compileroptionen-Einstellungen steuern, wie die ausführbare Datei erzeugt wird. Das Kontrollkästchen Mit Debug-Information gibt an, ob der ausführbaren Datei symbolische Debug-Informationen hinzugefügt werden. Dieses Kontrollkästchen muß markiert sein, wenn Sie den integrierten Debugger verwenden wollen.
Das Kontrollkästchen Warnungen anzeigen gibt an, ob bei der Kompilierung Warnungen ausgegeben werden. Ihr Projekt wird erfolgreich kompiliert, wenn es Warnungen enthält. Dieses Kontrollkästchen bewirkt, daß die Warnungen in der Meldungsanzeige ausgegeben werden.
Das Kontrollkästchen Stabilität von Packages prüfen gibt an, ob sogenannte »stabile« Pakete vom Compiler geprüft werden sollen, um festzustellen, ob sie aktualisiert werden sollen. Pakete wie java oder jbcl werden als stabil (selten verändert) betrachtet und werden deshalb beim Aktualisieren normalerweise nicht überprüft, was Zeit beim Kompilieren spart. Wenn Sie den Compiler zwingen wollen, stabile Pakete zu prüfen, markieren Sie dieses Kontrollkästchen.
Das Kombinationsfeld Klassen ausschließen ermöglicht Ihnen, .class-Dateien anzugeben, die der Compiler nicht kompilieren soll. Das kann sinnvoll sein, wenn Sie gerade den Quellcode für eine Klasse ändern, so daß er inkompatibel wird. Eine Aktualisierung würde diese veränderte Datei normalerweise berücksichtigen und Compiler-Fehler erkennen, die Sie noch nicht korrigiert haben. Wenn Sie in dieses Kombinationsfeld einen Klassennamen eintragen, können Sie alle anderen Knoten kompilieren, indem Sie den Aktualisieren-Befehl für das gesamte Projekt ausführen, aber die hier aufgelisteten Klassen werden vom Compiler ignoriert. Sie können auch die Durchsuchen-Schaltfäche verwenden, um die auszuschließende Klasse interaktiv zu ermitteln.
Das Kombinationsfeld Codierung bietet Ihnen die Möglichkeit, eine andere Codierung zu spezifizieren, womit Sie steuern, wie Nicht-ASCII-Zeichen interpretiert werden. Wenn diese Option auf Ohne gesetzt ist, wird die Standard-Codierung der Plattform verwendet. Wenn Sie diese Option setzen, werden die Plattformen eingeschränkt, auf denen Ihr Programm korrekt funktioniert, seien Sie also vorsichtig mit dieser Auswahl.
Die Standardpfadnamen, die Sie in einem neuen Projekt verwenden, werden normalerweise zunächst bei der JBuilder-Installation festgelegt. Sie können auch IDE-übergreifende Projektoptionen festlegen, indem Sie Tools | Umgebungsoptionen wählen und im Dialog Umgebungsoptionen die entsprechenden Auswahlen treffen. Hier legen Sie fest, was im Eigenschaftendialog für ProjektName.jpr erscheint. Wenn Sie in diesem Dialog auf die Vorgabe-Schaltfläche klicken, werden die Optionen auf die Werte der Installation zurückgesetzt.
Die Einstellungen für die Compileroptionen in einem Projekt überschreiben die Compileroptionen für die Umgebung, Sie können sich den Dialog für die Umgebungsoptionen also als Ausgangspunkt für alle Projekte vorstellen. Anschließend können Sie die einzelnen Projekte im Eigenschaftendialog anpassen.
Die zweite Seite des Eigenschaftendialogs erscheint im Dialog für die Umgebungsoptionen nicht. Diese Seite ist in Abbildung 11.3 gezeigt.
Abbildung 11.3: Die Start/Debug-Eigenschaften für das Welcome-Projekt
Auf der Start/Debug-Seite können Sie eigenschaftsspezifische Optionen angeben, die steuern, wie das Programm ausgeführt wird, wenn Sie die Befehle Start oder Debug verwenden. In diesem Dialog können Sie Optionen setzen, die alle Dateien Ihres Projekts betreffen. Alle Dropdown-Listen des Dialogs zeigen Werte an, die in früheren Sitzungen gewählt wurden. Weil Sie in der Standardkonfiguration ein Projekt implizit Kompilieren, wenn Sie die Befehle Start oder Debug ausführen, wollen wir diese Optionen jetzt genauer betrachten.
Die Gruppe Debug-Optionen enthält mehrere Einträge, die steuer, welche Dateien ausgeführt werden, welche Parameter in den Befehlszeilen bereitgestellt werden, und ob ein Knoten vor dem Debugging kompiliert wird.
Die Option Vorgegebene ausführbare Datei ermöglicht Ihnen die Angabe, welche Datei im Projekt standardmäßig ausgeführt wird, wenn Sie den Befehl Start auswählen. Wenn Sie Start wählen und eine andere Datei wird ausgeführt, als Sie erwarten, dann sollten Sie hier nachsehen! Wenn in diesem Kombinationsfeld ein Eintrag steht und Sie den Befehl Start aus dem Start-Menü ausführen (oder seine Icon-Darstellung in der Symbolleiste), bestimmt diese Option, welche Datei ausgeführt wird. Wenn das Kombinationsfeld leer ist, oder wenn Sie den Start-Befehl aus dem Popup-Menü für den Knoten ausführen, wird diese Option ignoriert und statt dessen wird der ausgewählte Knoten ausgeführt.
Im Kombinationsfeld Befehlszeilenparameter können Sie angeben, welche Argumente das Programm für die aktuelle Ausführung verwenden soll. Damit können Sie beim Testen Ihres Programms in der IDE verschiedene Argumente ausprobieren. Wenn dieses Kombinationsfeld leer ist, werden Ihrem Programm keine Argumente übergeben, womit Sie testen können, wie Ihr Programm eine null-Parameterliste verarbeitet.
Das Kombinationsfeld Parameter für VM ermöglicht die angabe von Befehlszeilenoptionen für die Virtuelle Maschine von Java. Die gültigen Parameter sind plattformspezifisch. Die einfachste Methode, zu ermitteln. welche Parameter für eine Plattform erlaubt sind, ist, an einem Befehlsprompt java ohne Argumente einzugeben und die Eingabetaste zu drücken. Dadurch werden alle für die Plattform verfügbaren Befehlszeilenoptionen angezeigt. Unter anderem kann es sich dabei um die Heap-Größe, die Stack-Größe und die Aktivierung oder die Deaktivierung der Speicherbereinigung handeln.
Das Kontrollkästchen Projekt vor Debuggen compilieren steuert, ob beim Aufruf von Start oder Debug eine implizite Kompilierung erfolgt, bevor versucht wird, das Programm auszuführen. Dieses Kontrollkästchen wird standardmäßig markiert, aber wenn Sie nicht wollen, daß die IDE bei jeder Ausführung von Start oder Debug eine Kompilierung vornimmt, sollten Sie die Markeriung entfernen.
Die Gruppe Konsolen-I/O steuert, wo Standardausgaben und Standardfehlermeldungen angezeigt werden. Das Optionsfeld Ausgabe zum Ausführungsprotokoll senden leitet Ihre Programmausgabe in das Ausführungsprotokoll-Fenster, das Sie durch Ansicht | Ausführungsprotokoll anzeigen. Das Optionsfeld Ausgabe zum Konsolenfenster senden leitet Ihre Programmausgabe auf das Konsolenfenster des Web-Browsers.
Auch hier setzt die Vorgabe-Schaltfläche die Optionen auf die Installationswerte zurück.
Wenn Sie Ihr Projekt aktualisieren oder neu erstellen, erhalten Sie manchmal einen Compiler-Fehler, es sei denn, Sie sind wirklich sehr vorsichtig. Eine der Editorfunktionen, die Hervorhebung der Syntax, kann helfen, Syntaxfehler zu erkennen, bevor Sie Ihr Programm kompilieren, aber es gibt auch subtilere Fehler. In diesem Abschnitt betrachten Sie ein Programm, das mit Fehlern durchsetzt wurde, so daß Sie sehen, wie diese Fehler im Inhalts-Bereich des AppBrowsers sowie in der Meldungsanzeige erscheinen.
Klicken Sie bei geöffnetem Projekt CompileDebug.jpr auf das Icon Dem Projekt hinzufügen im Navigations-Bereich des AppBrowsers. Geben Sie in das Dateinamen-Feld HelloDebug.java ein und klicken Sie auf die Schaltfläche Öffnen. Im Inhaltsbereich geben Sie den Code mit den Syntaxfehlern ein, den Sie in Listing 11.1 sehen.
Listing 11.1: HelloDebug.java (mt Syntaxfehlern)
1: import java.applet.*;
2: import java.awt.*;
3:
4: public class HelloDebug extends Applet {
5:
6: public void init() {
7: Font f = new Font("Helvetica, Font.BOLD, 36);
8: setFont(f);
9: }
10:
11: public void paint(Graphics g) {
12: g.drawString("Hello!", 50, 50)
13: }
14:
15: }
Das Applet in Listing 11.1 erzeugt beim Kompilieren Fehler! Wenn Sie Listing 11.1 betrachten, sehen Sie vielleicht sofort zwei Syntaxfehler. In Zeile 7 fehlt bei der Deklaration des Font-Objekts das doppelte Anführungszeichen am Ende des Schriftnamens. In Zeile 12 fehlt das schließende Semikolon - ein häufiger Fehler.
Die Syntax-Hervorhebung des Editors kann verwendet werden, um einige Syntaxfehler zu erkennen Wählen Sie den Knoten HelloDebug.java, klicken Sie mit der rechten Maustaste auf den Inhalts-Bereich und wählen Sie den Befehl Eigenschaften. Dieser Befehl zeigt die Optionsseite des Dialogs Umgebungsoptionen an, für Editor, Anzeige und Farben.
Klicken Sie auf die Registerkarte Farben und dann in der Element-Liste auf String, so daß der Dialog aussieht wie in Abbildung 11.4 gezeigt.
Abbildung 11.4: Auf der Farben-Seite wurde das String-Element ausgewählt
Vorausgesetzt, Sie verwenden das Standard-Farbschema, enthält der Dialog in dem oberen linken Farbfeld die Angabe VG, und das Kontrollkästchen Vorgabe für Hintergrund ist markiert. Klicken Sie mit der linken Maustaste auf das Farbfeld unten links, Blau, und dann auf die OK-Schaltfläche. Im Inhalts-Bereich wird sofort sichtbar, daß der Helvetica-String nicht korrekt abgeschlossen ist, weil die restliche Zeile dieselbe Farbe hat wie der String.
Experimentieren Sie ein bißchen mit den Farben für verschiedene Syntaxelemente. Neben der Vordergrundfarbe des Texts können Sie auch die Hintergrundfarbe verändert. Sie könnten beispielsweise Ihre Kommentare als blauen Text auf gelbem Hintergrund darzustellen, damit sie auffallen. Sie können aber auch die Schriftattribute ändern (fett, kursiv und unterstrichen).
Es gibt vier Möglichkeiten einer Farb-Schnelleinstellung, die Ihnen vordefinierte Farben vorschlagen. Sie können sie wie definiert verwenden, oder als Ausgangspunkt für Ihr eigenes, spezielles Farbschema. Das Textfeld unten im Dialog zeigt die einzelnen Codeelemente in einem Beispielprogramm. Sie können einfach ein Element anklicken und seine Einstellungen bearbeiten. Sie müssen also nicht einmal wissen, wie ein Element heißt, um seine Syntaxattribute zu verändern. Wenn Sie beispielsweise auf void klicken, sehen Sie, daß es sich dabei um ein reserviertes Wort handelt, das standardmäßig in schwarz und auf dem Standard-Hintergrund dargestellt wird.
Andere Syntaxfehler sind nicht so einfach zu erkennen. Sie werden deutlich, wenn Sie versuchen, Ihr Programm zu kompilieren. Selektieren Sie im Navigations-Bereich HelloDebug.java, klicken Sie mit der rechten Maustaste und wählen Sie im Popup-Menü den Befehl Aktualisieren.
Theoretisch würden Sie erwarten, daß ein Syntaxfehler einen Compiler-Fehler erzeugen würde, aber es gibt keinen so intelligenten Compiler, wie Sie gleich sehen werden - obwohl JBuilder besser als die meisten anderen ist.
Wenn der Compiler fertig ist, sehen Sie drei Fehler in der Meldungsanzeige, wie in Abbildung 11.5 gezeigt.
Abbildung 11.5: Fehler, die bei der Kompilierung von HelloDebug.java entstehen
Wenn Sie in den ersten 10 Lektionen alle Beispiele korrekt abgetippt haben, dann ist dies möglicherweise die erste Fehlermeldung, die Sie in der IDE sehen. Der erste Teil, Fehler:, zeigt an, daß es sich hier um einen Syntaxfehler und nicht um eine Warnung handelt. Fehler sind fatal - d.h. Ihr Programm wird nicht kompiliert, bis das Problem behoben ist. Im nächsten Teil wird in Klammern angegeben, welche Zeile im Quellcode das Problem verursacht hab. Nach der Zeilennummer kommt die eigentliche Fehlermeldung, die Ihnen den Fehler kurz beschreibt. Die erste Fehlermeldung, in diesem Fall:
Fehler: (6) unclosed literal character.
teilt Ihnen mit, daß in Zeile 7 ein fataler Fehler vorliegt, und das Problem ist, daß Sie ein -Zeichen-Literal in dieser Zeile nicht richtig geschlossen haben.
Es gibt noch mehr zu Abbildung 11.5 zu sagen:
Jetzt zurück zur Meldungsanzeige. Diese erste Fehlermeldung teilt Ihnen mit, daß Sie ein doppeltes Anführungszeichen am Ende von Helvetica vergessen haben, um den String zu schließen. Der Cursor wird am String-Ende positioniert, so daß Sie das Problem gleich sehen. Warum sagt der Compiler, Sie hätten ein nicht geschlossenes Zeichen-Literal, wenn es sich um einen nicht geschlossenen String handelt? Der Compiler sieht das erste Anführungszeichen als Zeichen und weiß jetzt, daß er ein weiteres Anführungszeichen erwarten soll. Er weiß nicht, ob Sie ein Zeichen-Literal oder einen String beabsichtigt haben, sondern nur, daß es kein schließendes Anführungszeichen gibt. Diese Logik sollte Ihnen vertraut werden, damit Sie Fehlermeldungen interpretieren können.
Jetzt betrachten wir die beiden anderen Fehlermeldungen. Dazu klicken Sie entweder mit der Maus auf die nächste Meldung, oder Sie verwenden Ansicht | Nächste Fehlermeldung. Die zweite Fehlermeldung:
In Zeile 12 wurde ein Semikolon erwartet, und der Cursor ist am Zeilenende positioniert. Das scheint einfach zu sein. Die dritte und letzte Fehlermeldung lautet:
Fehler: (3) constructor Font (<any>) not found in class java.awt.Font.
Aber warum gibt es eine dritte Meldung, wenn nur zwei Fehler vorhanden sind? Diese Meldung entsteht dadurch, daß der Compiler nach der Syntaxprüfung auch die Verweise auf Klassen und Methoden überprüft. Aufgrund des fehlenden Anführungszeichens in Zeile 7 kann er die Font()-Konstruktoranweisung nicht auflösen, weil sie nicht korrekt formuliert ist, so daß ein weitere Fehler entsteht.
Jetzt korrigieren wir den ersten Fehler. Dazu können Sie entweder mit der Maus auf den ersten Fehler klicken, oder Sie verwenden zweimal den Befehl Ansicht | Vorherige Fehlermeldung. Positionieren Sie den Cursor am Ende des Strings Helvetica und fügen Sie vor dem Komma ein Anführungszeichen ein. Sonst sollten Sie jetzt noch nichts machen. Selektieren Sie HelloDebug.java, klicken Sie mit der rechten Maustaste und wählen Sie Aktualisieren. Das Ergebnis sehen Sie in Abbildung 11.6.
Abbildung 11.6: Der nächste Fehler beim Kompilieren von HelloDebug.java
Beachten Sie, daß mit einer Korrektur zwei Fehler behoben wurden. Wenn der String Helvetica jetzt korrekt abgeschlossen ist, wird auch der Font()-Konstruktor richtig aufgelöst. Der Cursor wird jetzt im Code positioniert, wo das Semikolon fehlt. Fügen Sie es ein und kompilieren Sie noch einmal. Das Programm sollte jetzt fehlerfrei kompiliert werden.
Wenn in der Meldungsanzeige ein Fehler angezeigt wird, achten Sie auf die Fehlernummer und den Typ (Fehler oder Warnung). Weitere Informationen über den Fehler finden Sie über Hilfe | Hilfethemen, wo Sie nach der Bedeutung von Fehlermeldungen suchen können.
Wenn Sie Ihre Anwendung erfolgreich kompiliert haben, können Sie Ihr Programm testen. Eine Beschreibung vollständiger Tests kann im Rahmen dieses Buchs nicht geboten werden, aber es soll Ihnen zeigen, welche grundlegenden Prüfungen Sie für Ihr Programm vornehmen sollten, damit es von allen Anwendern verwendet werden kann, für die es vorgesehen ist.
Grundlegende Tests bedeuten das Ausprobieren aller Menüeinträge, die Eingabe verschiedener Werte in Eingabefelder, die Überprüfung der Anzeige grafischer Elemente und eine Prüfung der Ausgabe auf verschiedenen Geräten. Einen Großteil dieser Tests können Sie in der IDE ausführen, indem Sie die Anwendung starten. Um Ihr Projekt zu starten, wählen Sie Start | Start. Ihr Programm wird geladen und ermöglicht Ihnen die Interaktion wie sie einem Anwender geboten wird. Wenn etwas nicht korrekt funktioniert oder wenn Sie einen Laufzeitfehler erhalten, sollten Sie Ihr Programm mit dem integrierten Debugger der IDE debuggen.
Um Ihr Projekt zu debuggen, wählen Sie Start | Debug. Dadurch wird Ihr Projekt in den integrierten Debugger geladen, wo Sie es schrittweise durchlaufen und die Werte und Stati Ihrer Variablen und Objekte auswerten können.
Der integrierte Debugger ermöglicht Ihnen, Ihren Code auf kontrollierte Weise zu durchlaufen. Außerdem könne Sie hier verschiedene Szenarios ausprobieren, seltsame Fehler finden und die Werte zu jedem Zeitpunkt der Programmausführung überprüfen. Sie können Ihren Code zeilenweise durchlaufen und bestimmte Teile des Quellcodes überspringen.
Bevor Sie mit dem Debugging im integrierten Debugger beginnen können, müssen Sie sicherstellen, daß bestimmte Projektoptionen aktiviert sind. Die Debugging-Optionen sind im Eigenschaftendialog für das Projekt enthalten. Wenn Sie Debuggen, setzen Sie Ihre Projektoptionen auf die in Tabelle 11.1 gezeigten Wert.
Tabelle 11.1: Projektoptionen für das Debugging
Wenn Sie Vorgegebene ausführbare Datei nicht auf die betrachtete Quellcodedatei setzen, können Sie das Popup-Menü des selektierten Knotens verwenden, um den Debug-Befehl auszuwählen, der diese Option überschreibt.
Bevor Sie Ihre Debug-Sitzung beginnen, können Sie die Parameter auf der Start/Debug-Seite ändern, um verschiedene Argumente auszuprobieren.
Um den integrierten Debugger zu verwenden, wählen Sie den Debug-Befehl, entweder im Popup-Menü des selektierten Knotens, im Start-Menü oder durch Anklicken der Icon-Darstellung in der Symbolleiste (ein Blitz mit einer Wanze). Wenn Sie Haltepunkte gesetzt haben (die Sie gleich kennenlernen), können Sie eine Debug-Sitzung auch mit Start aufrufen.
Beim Aufruf des Debuggers erfolgt ein implizites Aktualisieren für den selektierten Knoten. Das kann eine Datei, ein Paket oder ein Projekt sein. Wenn die Kompilierung erfolgreich war, wird Ihr Programm ausgeführt. Sobald prozeduraler Code aufgerufen wird, wird der Ausführungspunkt im Editorfenster angezeigt, wie in Abbildung 11.7 gezeigt.
Abbildung 11.7: Der Ausführungspunkt
Der Ausführungspunkt ist die Codezeile, die in einer Debug-Sitzung gerade ausgeführt wird. Der Ausführungspunkt wird farblich hervorgehoben und in der linken Spalte des Editor-Fensters wird ein Pfeil angezeigt. Wenn Sie noch keine Haltepunkte oder Ausdrücke gesetzt haben, können Sie das tun, wenn ein Ausführungspunkt angezeigt und Ihr Programm unterbrochen ist. Wenn Sie eine andere Codezeile angeklickt haben und den Cursor wieder am Ausführungspunkt positionieren wollen, wählen Sie dazu Start | Ausführungsposition anzeigen.
Immer wenn Ihr Programm eine Eingabe vom Anwender erwartet, können Sie den Befehl Start | Programm unterbrechen wählen, um die Ausführung im integrierten Debugger vorübergehend zu unterbrechen. Damit können Sie auch die Einstellungen ändern, etwa Haltepunkte oder Ausdrücke. Um die Programmausführung fortzusetzen, können Sie einen von vier Befehlen im Start-Menü verwenden: Routine überspringen, Routine verfolgen, Ausführung bis Cursorposition oder Ausführung bis Ende der Methode.
Routine verfolgen veranlaßt den Debugger, jede einzelne Codezeile auszuführen, auch alle Zeilen in aufgerufenen Methoden. Wenn dieser Befehl verwendet wird und der Debugger auf einen Methodenaufruf trifft, führt er den Methodenaufruf aus und positioniert den Ausführungspunkt in der nächsten Codezeile innerhalb dieser Methode.
Durch Routine überspringen wird der Debugger veranlaßt, jede Codezeile auszuführen, außer aufgerufene Methoden. Wenn der Debugger auf einen Methodenaufruf trifft, betrachtet er alle Anweisungen in dieser Methode als Gruppe und positioniert den Ausführungspunkt auf der Anweisung, die dem Methodenaufruf unmittelbar folgt.
Um den Befehl Ausführung bis Cursorposition zu verwenden, positionieren Sie den Cursor im Editor auf der Codezeile, in der Sie das Debugging beginnen (oder fortsetzen) wollen. Dieser Befehl führt Ihr Programm aus, bis er die Codezeile mit dem Cursor erreicht. Jetzt wird der Ausführungspunkt an dieser Stelle gesetzt und Sie können von hier aus das Programm schrittweise weiterausführen.
Der Befehl Ausführung bis Ende der Methode veranlaßt den Debugger, von dem Befehl bis zum Ende der aktuellen Methode zu laufen. Der Ausführungspunkt wird auf die Zeile gesetzt, die dem Methodenaufruf unmittelbar folgt. Dieser Befehl ist insbesondere dann praktisch, wenn Sie eine Methode verfolgen und nicht mehr alle weiteren Codezeilen einzeln durchlaufen wollen.
Um die Debug-Sitzung zu beenden, die Programmausführung zu unterbrechen und es aus dem Speicher zu entladen, wählen Sie Start | Programm zurücksetzen. Beachten Sie jedoch, daß das Programm dadurch sofort beendet wird und möglicherweise nicht alle Windows-Ressourcen freigibt, die Ihr Code alloziert hatte. Um sicherzustellen, daß alle während einer Debug-Sitzung allozierten Ressourcen freigegeben werden, müssen Sie möglicherweise JBuilder beenden und neu starten, bevor Sie weitere Debug-Sitzungen starten können.
Wenn Sie Ihr Programm im Debugger ausführen, läuft es mit voller Geschwindigkeit, es sei denn, Sie unterbrechen es an irgendeiner Stelle. Haltepunkte zeigen dem Debugger, daß Sie die Ausführung unterbrechen wollen, wenn Sie in die Zeile mit dem Haltepunkt gelangen.
Ein Haltepunkt ist eine markierte Codezeile, in der der Debugger die Programmausführung
unterbricht. Ein Haltepunkt kann nur in einer Zeile gesetzt werden, die ausführbaren Code erzeugt, nicht in
Kommentaren, Leerzeilen oder Deklarationen. Sie werden nicht gehindert, in diesen Zeilen einen Haltepunkt
zu setzen, aber der Debugger warnt Sie, daß Sie einen Haltepunkt in einer Zeile gesetzt haben, die keinen
Code enthält. Ungültige Haltepunkte werden vom Debugger einfach ignoriert. Auf return-Anweisungen oder
schließenden geschweiften Klammern einer Methode sind Haltepunkte gültig.
Um einen Haltepunkt zu kennzeichnen, wird an linken Rand des Editors ein roter Punkt angezeigt, wie in Abbildung 11.8 gezeigt.
Abbildung 11.8: Ein Haltepunkt im Editor-Fenster
Sie können im Editor nicht nur Haltepunkte setzen, sondern auch den Befehl Start | Haltepunkt hinzufügen wählen, um den Dialog für die Haltepunktoptionen aufzurufen. In JBuilder gibt es zwei Arten von Haltepunkten, normale Haltepunkte und Ausnahme-Haltepunkte, also Exception-Haltepunkte. Die normalen Haltepunkte werden in einer bestimmten Zeile im Quellcode gesetzt. Sie bewirken, daß die Ausführung in dieser Zeile unterbrochen wird. Exception-Haltepunkte werden aufgerufen und unterbrechen die Ausführung, wenn eine bestimmte Ausnahme aufgeworfen wird.
Abbildung 11.9 zeigt die Seite mit den Haltepunktoptionen für normalen Haltepunkte.
Abbildung 11.9: Haltepunktoptionen für normale Haltepunkte
Haltepunkte können unterschiedliche Optionen erhalten, die steuern, wie sie aufgerufen werden. Sie können den Dateinamen und die Zeilennummer setzen, für die der Haltepunkt gelten soll. Die Bedingung ist ein Ausdruck, der die Programmausführung unterbricht, wenn er erfüllt ist. Auf der Aktion-Seite können Sie dem Haltepunkt einer Gruppe von Haltepunkten zuordnen. Die Thread-Optionen steuern, ob dieser Haltepunkt die Ausführung aller Threads oder nur eines bestimmten Threads beeinflußt. Sie können steuern, wie oft der Haltepunkt ignoriert wird, bevor die Ausführung unterbrochen wird. Wenn Sie beispielsweise einen Haltepunkt in einer Schleife haben, die 20mal ausgeführt wird, können Sie veranlassen, daß der Haltepunkt nur beim letzten Schleifendurchgang ausgeführt wird.
Abbildung 11.10 zeigt die Definitionsseite für Exception-Haltepunkte.
Abbildung 11.10: Definitionsseite für Exception-Haltepunkte
Wie Sie sehen, sind für Exception-Haltepunkte einige Optionen anders. Statt des Dateinamens und der Zeilennummer geben Sie an, für welche Ausnahme Sie den Haltepunkt ausführen wollen. Der Standard ist Auslösen von allen aufgefangenen Exceptions, aber Sie können auch Auslösen von nicht aufgefangenen Exceptions oder Abgefangenes Auslösen von Klasse verwenden und eine bestimmte Klasse angeben. Alle weiteren Optionen auf der Seite sind der für die normalen Haltepunkte gleich, außer daß sie für die jeweilige Ausnahme angewendet werden.
Abbildung 11.11 zeigt die Aktion-Seite.
Abbildung 11.11: Die Aktion-Seite für beide Arten von Haltepunkten
Diese Seite enthält für beide Arten von Haltepunkten dieselben Optionen. Sie können eine beliebige Kombination von Aktionen bestimmen, die erfolgen sollen, wenn ein Haltepunkt erreicht ist. Eine der Optionen ist interessanterweise die Möglichkeit, Ausführung anhalten zu deaktivieren, was sinnvoll sein kann, wenn Sie einige der anderen Optionen aktivieren oder deaktivieren. Die Option Dialog beim Auftreten eines Haltepunkts ermöglicht die Anzeige eines Dialogs, wenn ein Haltepunkt erreicht ist. Auftreten des Haltepunkts protokollieren bewirkt, daß eine Meldung in das Debug-Protokoll geschrieben wird, wenn der Ausdruck true ergibt. Die Kontrollkästchen Anderen Haltepunkt aktivieren/deaktivieren bewirkt, daß die angegebenen Haltepunkte beim Erreichen aktiviert/deaktiviert werden. Gruppe von Haltepunkten aktivieren/deaktivieren bewirkt, daß die angegebene Gruppe der Haltepunkte aktiviert/deaktiviert wird, wenn der aktuelle Haltepunkt erreicht ist. Diese vier Optionen beziehen sich auf die Namen- und Gruppennamen-Optionen aus der Definitionsseite für den aktuellen Haltepunkt.
Um zu sehen, welche Haltepunkte in der aktuellen Debug-Sitzung aktiviert sind, verwenden Sie Ansicht | Haltepunkte, um das Haltepunkte-Fenster anzuzeigen (Abbildung 11.12).
Abbildung 11.12: Das Haltepunkte-Fenster und sein Popup-Menü
Im Popup-Menü des Haltepunkte-Fensters haben Sie Zugriff auf die gebräuchlichsten Befehle, ohne den Dialog für die Haltepunkte aufrufen zu müssen. Abbildung 11.12 zeigt die Befehle des Popup-Menüs. Die meisten dieser Befehle sind selbsterklärend. Der Befehl Optionen zeigt die aktuellen Haltepunktoptionen an. Der Befehl Haltepunkt hinzufügen ruft den Dialog für die Haltepunktoptionen auf.
Ausdrücke sind Bezeichner oder Ausdrücke, die einen oder mehrere Bezeichner enthalten, deren Werte Sie bei der Programmunterbrechung auswerten wollen. Ausdrücke können nur die Bezeichner im aktuellen Gültigkeitsbereich »sehen«. Wenn ein Bezeichner oder ein Bezeichner in einem Ausdruck den Gültigkeitsbereich verläßt, ist der Ausdruck undefiniert.
Ein Ausdruck kann fast alles enthalten, was eine normael Zuweisung enthalten kann, außer einem
Methodenaufruf auf der rechten Seite des Zuweisungsoperators.
Wenn sich der AppBrowser im Debug-Modus befindet, bewirkt das Anzeige der Debug-Registerkarte, daß zwei weitere Ansichten angezeigt werden: Thread- und Stack-Feld sowie Daten-Feld.
Das Feld für Threads und Stack befindet sich oben links. Es zeigt die Threads, Methoden und Parameter an, die bis zum aktuellen Ausführungspunkt aufgerufen wurden. Der Stack zeigt den Namen der aktuell ausgeführten Methode und aller zuvor aufgerufenen Methoden an. Jedes Element listet die Methodennamen auf, ebenso wie die Werte der aufrufenden Parameter. Threads sind Unterprozesse in Ihrer Anwendung. Auch wenn Sie keine Multithreading-Anwendung verwenden, wird der Standard-Thread für Ihr Programm in diesem Fenster angezeigt, und sein Fortschritt wird beobachtet.
Das Datenfeld unten links zeigt, welchen aktuellen Wert ein Objekt hat. Damit können Sie den Status eines Objekts auswerten, wenn Ihr Programm unterbrochen ist.
Sie können auch bestimmen, welche Arten von Information in diesen Felder angegeben werden. Klicken Sie mit der rechten Maustaste auf das Thread&Stack-Feld oder auf das Datenfeld und wählen Sie Eigenschaften, um den Eigenschaftendialog anzuzeigen (Abbildung 11.13).
Abbildung 11.13: Der Kontextbaum-Eigenschaftendialog
In diesem Dialog können Sie festlegen, welche Daten in den Feldern angezeigt werden sollen. Die meisten der Auswahlmöglichkeiten sind selbsterklärend, aber eine soll besonders erwähnt werden. Es handelt sich um die beiden Optionsfelder unterhalb des Kontrollkästchens Anzeige von Daten. Diese Optionsfelder steuern, ob die folgenden Kontrollkästchen als Datentypen betrachtet werden sollen, die nicht angezeigt werden (Daten verbergen), oder ob sie angezeigt werden sollen (Daten anzeigen).
Es gibt noch drei andere Sichten und Fenster, die beim Debugging zur Verfügung stehen, und die Ihnen Informationen über Ihr Programm anzeigen sollen. Dieser Abschnitt stellt sie kurz vor.
Im Überprüfen-Dialog können Sie ein Datenelement auswerten, etwa einen Eigenschaftswert oder Programmdaten. Der Wert wird während der Programmausführung in der Debug-Sitzung aktualisiert. Dieser Dialog wird mit Start | Überprüfen aufgerufen. mmand
Der Auswerten/Ändern-Dialog ermöglicht Ihnen, einen Ausdruck auszuwerten oder Datenelemente beim Debugging vorübergehend zu ändern, etwa Eigenschaftswerte. Dieser Dialog wird mit Start | Auswerten/Ändern aufgerufen. Im Kombinationsfeld Ausdruck geben Sie den Bezeichner, die Konstante oder den Ausdruck ein, den Sie auswerten wollen, oder Sie wählen einen der Einträge aus der Liste bereits ausgewerteter Ausdrücke. Klicken Sie auf die Schaltfläche Auswerten, um das Ergebnis der Auswertung im Ergebnis-Feld anzuzeigen. Um einen Wert zu ändern, geben Sie den neuen Wert in das Kombinationsfeld Neuer Wert ein und klicken auf die Schaltfläche Ändern. Damit können Sie einen gewünschten Wert eingeben und das Debugging fortsetzen.
Das Fenster Geladene Klassen zeigt eine Liste aller Klassen an, die für die aktuelle Klasse in der Debug-Sitzung benötigt werden. Dieses Fenster wird mit dem Befehl Ansicht | Geladene Klassen aufgerufen.
Heute haben Sie gelernt, Ihren Code für die Kompilierung vorzubereiten. Sie wissen, wie die Syntaxhervorhebung verwendet wird, und können entscheiden, ob Sie aktualisieren oder neu erstellen sollten. Sie können diese Befehle auf unterschiedliche Weisen aufrufen. Außerdem haben Sie erfahren, daß Start und Debug ein implizites Kompilieren vornehmen, und Sie haben den Debugger kennengelernt.
F Auf welche häufigen Fehler sollten Neulinge in der Java-Programmierung achten?
A Es gibt drei gebräuchliche Fehler, die zu Compiler-Fehlern führen. Achten Sie bei der Codeeingabe auf folgende Dinge:
F Wenn ich versuche, mein Applet zu Debuggen, zeigt die IDE eine Meldung an, daß JBuilder MyApplet.java (oder welches auch immer) nicht debuggen kann. Was ist los?
A Das Problem ist, daß der integrierte Debugger weiß, daß das Applet über eine HTML-Datei aufgerufen werden muß, er weigert sich also, Ihre .java-Datei direkt zu debuggen. Um ein Applet zu debuggen, müssen Sie den entsprechenden HTML-Knoten selektieren und dann den Debug-Befehl ausführen, so, als ob Sie das Applet ausführen würden.
Der Workshop bietet zwei Möglichkeiten, zu überprüfen, was Sie in diesem Kapitel gelernt haben. Der Quiz-Teil stellt Ihnen Fragen, die Ihnen helfen sollen, Ihr Verständnis für den vorgestellten Stoff zu vertiefen. Die Antworten auf die Fragen finden Sie in Anhang A. Der Übungen-Teil ermöglicht Ihnen, Erfahrungen in der Anwendung der Dinge zu sammeln, die Sie hier kennengelernt haben. Versuchen Sie, diese Dinge durchzuarbeiten, bevor Sie mit der nächsten Lektion weitermachen.
Nehmen Sie eines der Projekte aus den früheren Lektionen und setzen Sie Haltepunkte. Probieren Sie alle Debug-Befehle aus und experimentieren Sie damit. Erstellen Sie ein neues Projekt und kopieren Sie funktionierenden Code in dieses Projekt, erzeugen Sie ein paar Syntaxfehler und beobachten Sie die Reaktion des Compilers.
