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.*; 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 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.
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.
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.
Start/Debug-Optionen
Syntaxfehler
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!
Codeeditor-Optionen
Compiler-Fehler
Hilfe bei Fehlern
Der Debugger
Debugging-Optionen
Aufruf des Debuggers
Der Ausführungspunkt ist die Codezeile, die in einer Debug-Sitzung gerade ausgeführt wird.
Unterbrechen und Fortsetzen
Zurücksetzen
Haltepunkte
Ein Haltepunkt ist eine markierte Codezeile, in der der Debugger die Programmausführung
unterbricht.
Haltepunkte sind praktisch, um das Programm an einem bestimmten Punkt zu unterbrechen, so daß Sie Ihre
Variablen auswerten, den Stack überprüfen und den Threadstatus einsehen können. Um einen Haltepunkt zu
setzen, klicken Sie im Inhalts-Bereich mit der rechten Maustaste auf die Codezeile und wählen im
Popup-Menü Haltepunkt umschalten.
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.
Ausdrücke
Ein Ausdruck kann fast alles enthalten, was eine normael Zuweisung enthalten kann, außer einem
Methodenaufruf auf der rechten Seite des Zuweisungsoperators.
Um die Ausdrücke zu überwachen, während Ihr Programm läuft, selektieren Sie die
Ausdruck-Registerkarte im AppBrowser. Im linken Feld werden die aktuell definierten Ausdrücke
angezeigt. Um einen Ausdruck hinzuzufügen, wählen Sie Start | Ausdruck hinzufügen, dann wird der
Dialog zum Hinzufügen eines Ausdrucks angezeigt.
Threads und Stack
Andere Debugging-Ansichten
Zusammenfassung
F&A
Workshop
Quiz
Übung
Ein Imprint des Markt&Technik Buch- und Software- Verlag GmbH
Elektronische Fassung des Titels: JBuilder in 14 Tagen, ISBN: 3-87791-895-6