In den glücklichen Zeiten, als man noch im Zeichenmodus programmierte, hat Borland als erster das Konzept der IDEs (Integrated Development Environment) eingeführt. Die IDE war der Durchbruch in den Entwicklungsumgebungen, weil sie es dem Entwickler ermöglichte, auf alle wichtigen Werkzeuge, die er für Sein Projekt brauchte, von einer einzigen Programmieroberfläche aus zuzugreifen. Unter anderem wurden dabei ein Editor, ein Compiler und ein Debugger bereitgestellt. Nachdem die meisten von uns heute grafische Umgebungen einsetzen und ganz einfach zwischen verschiedenen Programmen wechseln können, scheint das nicht mehr so revolutionär zu sein, aber bei ihrer Einführung stellten die IDEs ein zeitsparendes Konzept dar, das die Produktivität ganz erheblich steigerte.
Mit JBuilder bringt Borland dasselbe Konzept in die Java-Programmierung, die zuvor hauptsächlich mit befehlszeilenorientierten Werkzeugen bewerkstelligt wurde. Die JBuilder-IDE umfaßt ein Menüsystem, einen Browser, einen Editor, einen Designer, eine Komponenten-Symbolleiste, einen Eigenschaftsinspektor, Compiler und Linker sowie einen Debugger - alles, was Sie brauchen, um Ihre Java-Programme einfach und effizient zu erzeugen. Borlands Zweiwege-Werkzeug-Technologie ermöglicht Ihnen, grafisch oder textuell zu arbeiten, so daß Sie wählen können, welche Methode für Sie gerade am besten geeignet ist, während alles synchron bleibt.
Heute lernen Sie die Funktionen der IDE des JBuilder kennen und wie Sie sie für Ihre Aufgaben einsetzen können. Heute werden die folgenden Themenbereiche besprochen:
Bevor Sie die restliche IDE kennenlernen, sollten Sie wissen, daß es eine kontextabhängige Hilfe gibt, die auf dem Bildschirm erscheint, um Ihnen die einzelnen Teile der IDE vorzustellen. Wenn Sie Ihren Mauszeiger länger als eine halbe Sekunde über einer der Schaltflächen im Hauptfenster des JBuilder behalten, sehen Sie einen kleinen Tooltip mit Text (siehe Abbildung 5.1). Die Tooltips von JBuilder sollen zeigen, was die Schaltflächen, die keine Beschriftung tragen, bedeuten.
Abbildung 5.1: Eine Hilfe für die Schaltfläche Debug in der Symbolleiste
JBuilder bietet auch Hilfe, die für den Kontext, in dem Sie arbeiten, spezifisch ist. Sie können fast überall in der JBuilder-IDE F1 drücken, dann wird das entsprechende Thema in einem Hilfefenster beschrieben.
Wenn Sie beispielsweise herausfinden wollen, was ein bestimmter Menüeintrag bewerkstelligt, zeigen Sie das Menü an und markieren den Eintrag mit Hilfe der Pfeiltasten, ohne ihn jedoch zu selektieren. Drücken Sie F1, dann erscheint das Hilfefenster für diesen Menüeintrag. Natürlich können Sie auf die Hilfedateien auch direkt zugreifen, indem Sie eines der Elemente im Hilfemenü auswählen, oder indem Sie in den Dialogen die Hilfe-Schaltfläche anklicken.
Wenn Sie in einem IDE-Fenster oder -Feld mit der rechten Maustaste klicken, erscheinen kontextabhängige Popup-Menüs. Einige dieser Befehle stehen möglicherweise nicht in der Hauptmenüleiste zur Verfügung und die Befehlsmenge ändert sich danach, wo der Fokus gerade liegt. Schieben Sie beispielsweise den Mauszeiger über eines der Felder im AppBrowser-Fenster und klicken Sie mit der rechten Maustaste. Jetzt erscheint ein Popup-Menü, das für dieses Feld spezifisch ist. Popup-Menüs bieten Ihnen schnelleren Zugriff auf wichtige Befehle aus dem Kontext, wo Sie sie gerade benötigen.
Wenn Sie den JBuilder laden, wird als erstes das Hauptfenster angezeigt. Abbildung 5.2 zeigt das Hauptfenster des JBuilder mit Haupt-Menüleiste, Symbolleiste, Komponentenpalette und Statusleiste.
Abbildung 5.2: Das Hauptfenster des JBuilder
Die Haupt-Menüleiste gibt Ihnen Zugriff auf die Befehle von JBuilder, und zwar in hierarchisch dargestellter Textform, während die Symbolleiste die gebräuchlichsten Befehle in Icon-Format enthält. Die Komponentenpalette enthält die Drag&Drop-JavaBean-Komponenten, mit denen Sie die Benutzeroberfläche Ihrer Programme anlegen. Die Statusleiste zeigt die verschiedenen Meldungen an, etwa beim Speichern von Dateien oder über den Compiler-Status.
Neben den sichtbaren Teilen des Hauptfensters bietet JBuilder noch eine andere Möglichkeit, auf Befehle zuzugreifen - lokale Popup-Menüs, die in den einzelnen Fenstern und Ansichten des JBuilder zur Verfügung stehen. Dieses Popup-Menüs erscheinen, wenn Sie mit der rechten Maustaste auf die IDE klicken. In den angezeigten Fenstern erscheinen kontextabhängige Befehle. Im Hauptfenster beispielsweise hat die Komponentenpalette ein Popup-Menü, das Ihnen ermöglicht, einen Dialog anzuzeigen, mit dem Sie der Palette Komponenten hinzufügen und welche daraus entfernen können.
Das umfangreiche Menüsystem des JBuilder bietet Ihnen zahlreiche Befehle, die für die Ausführung Ihrer Aufgaben in der IDE benötigt werden. Die Haupt-Menüleiste ist ähnlich der in anderen Windows-Anwendungen. Sie enthält Menüelemente, die abhängig vom jeweiligen Kontext aktiviert oder deaktiviert sein können. Abbildung 5.3 zeigt die Haupt-Menüleiste von JBuilder.
Abbildung 5.3: Die Haupt-Menüleiste von JBuilder
Welche Menüeinträge Sie sehen, hängt davon ab, welche Version von JBuilder Sie einsetzen:
Standard, Professional (Pro) oder Client/Server (CS). Diese Information wird in der Beschreibung der
jeweilEine definitive Information, welche Funktionen in den einzelnen Versionen bereitstehen, finden Sie in der Dokumentation von JBuilder oder Sie wenden sich direkt an Borland.
Das Datei-Menü enthält die Befehle, die sich auf den Inhalt von Projekten und Quellcodedateien (im Speicher und auf Diskette), Projekteigenschaften, Druckbefehle und das Beenden des Programms beziehen. Abbildung 5.4 zeigt das Datei-Menü.
Diese Menüelemente sind aktiviert oder deaktiviert dargestellt, abhängig davon, welche Projektdatei selektiert ist, ob eine solche selektiert ist, und welchen Status das aktuell aktive Projekt hat.
Dieser Befehl zeigt den Dialog Neu an (siehe Abbildung 5.5).
Hier können Sie aus unterschiedlichen Datei- und Objekttypen wählen, die im AppBrowser geöffnet werden sollen. Der Dialog beinhaltet sieben Seiten mit Widgets, die die Object Gallery repräsentieren, die Sie später in diesem Kapitel kennenlernen.
Dieser Befehl zeigt den Dialog Projekt-Experte an, den Sie in Abbildung 5.6 sehen.
Abbildung 5.6: Der Dialog Projekt-Experte
In diesem Dialog können Sie Ihrem Projekt und Paket einen Namen zuweisen und den Produkttitel, den Autor, die Firma sowie eine Beschreibung für die interne Dokumentation bereitstellen.
Dieser Befehl zeigt den Dialog Datei öffnen/erstellen an. Abbildung 5.7 zeigt die Datei-Seite des Dialogs.
Abbildung 5.7: Der Dialog Datei öffnen/erstellen mit der Datei-Seite
Die Datei-Seite bietet Ihnen Zugriff auf das lokale Dateisystem, um eine existierende Datei zu öffnen oder eine neue Datei im Speicher zu erzeugen. Abbildung 5.8 zeigt die Packages-Seite des Dialogs.
Abbildung 5.8: Der Dialog Datei öffnen/erstellen mit der Packages-Seite
Auf der Packages-Seite können Sie entweder eines der existierenden Java-Pakete auf der Platte öffnen oder ein neues, eigenes Paket spezifizieren. Wenn Sie ein neues Paket anlegen, wird das entsprechende Verzeichnis auf der Platte erzeugt.
Beide Seiten beinhalten das Kontrollkästchen Dem Projekt hinzufügen, das, wenn es markiert wird, die neu erzeugte oder geöffnete Datei dem aktuell aktiven Projekt hinzufügt.
Durch die Auswahl von Neu öffnen wird ein Untermenü angezeigt, das die Projekte und Dateien anzeigt, die Sie zuletzt geöffnet hatten. Abbildung 5.9 zeigt, wie dieses Untermenü aussehen könnte, nachdem Sie das Welcome-Projekt zwei .java-Dateien hinzugefügt haben.
Abbildung 5.9: Ein einfaches Neu öffnen-Untermenü
Wenn Sie anfordern, daß ein Projekt erneut geladen wird, öffnet die IDE eine zweite Ansicht desselben Projekts.
Dieser Befehl schließt die aktuelle Datei. Wenn die Datei verändert wurde, werden Sie aufgefordert, diese Änderungen zu speichern oder sie zu verwerfen. Wenn es sich um eine Projekt-Datei handelt, werden alle Dateien auf Änderungen überprüft, bevor das Projekt geschlossen wird.
Dieser Befehl schließt das gesamte Projekt. Falls Dateien geändert wurden, werden Sie aufgefordert, diese Änderungen zu speichern oder sie zu verwerfen.
Dieser Befehl speichert die aktuell selektierte Datei auf der Festplatte. Wenn es sich um eine neue Datei handelt, wird der Befehl Speichern unter aufgerufen. Andernfalls wird sie unter ihrem aktuellen Namen abgelegt.
Dieser Befehl zeigt den Dialog Speichern unter an (siehe Abbildung 5.10).
Abbildung 5.10: Der Dialog Speichern unter
In diesem Dialog können Sie eine Datei unter einem neuen Namen oder/und an einer neuen Position speichern.
Dieser Befehl speichert die aktuell aktive .jpr-Projektdatei auf der Festplatte. Falls es sich um ein neues Projekt handelt, wird der Befehl Speichern unter aufgerufen, andernfalls wird das Projekt unter seinem aktuellen Namen auf der Festplatte abgelegt.
Dieser Befehl ruft automatisch den Befehl Speichern für alle veränderten Dateien des Projekts auf.
Dieser Befehl ermöglicht Ihnen, die ausgewählte Datei aus dem Projekt zu entfernen. Dadurch wird die Datei nicht von der Platte gelöscht. Der Befehl entfernt einfach nur den Dateieintrag aus der Projektdatei.
Dieser Befehl ruft den Dialog Speichern unter auf (siehe Abbildung 5.10), um die ausgewählte Datei umzubenennen. In diesem Dialog können Sie die Datei unter einem neuen Namen und/oder an einer neuen Position ablegen.
Dieser Befehl zeigt den Eigenschaften-Dialog ProjektName.jpr an. Die Projekt-Seite dieses Dialogs, die Sie in Abbildung 5.11 sehen, ermöglicht Ihnen, die Pfade sowie die Compiler-Optionen für das aktuell aktive Projekt zu ändern.
Abbildung 5.11: Der Eigenschaften-Dialog ProjectName.jpr, Projekt-Seite
Die Start/Debug-Seite dieses Dialogs, die Sie in Abbildung 5.12 sehen, ermöglicht Ihnen, Optionen für die Debugger-Sitzung einzustellen, etwa die Befehlszeilenparameter oder wo Konsolen-Ein/Ausgaben erfolgen sollen.
Abbildung 5.12: Der Eigenschaften-Dialog ProjectName.jpr, Start/Debug-Seite
Auf beiden Seiten gibt es eine Vorgabe-Schaltfläche, die Ihnen ermöglicht, bestimmte Optionen auszuwählen und diese dann zum Standard für alle zukünftigen Projekte zu machen.
Dieser Befehl ruft den Dialog Druckereinstellungen auf (Abbildung 5.13), wo Sie angeben können, welcher Drucker, welches Papier und welche Ausrichtung verwendet werden sollen.
Abbildung 5.13: Der Dialog zur Druckereinrichtung
Dieser Befehl reagiert unterschiedlich, je nachdem, welche Datei Sie ausgewählt haben und welche Registerkarte im Inhalts-Bereich aktiv ist. Wenn Sie eine .jpr- oder .html-Datei ausgewählt haben und der AppBrowser sich im Ansicht-Modus befindet (die Registerkarte Ansicht ist ausgewählt), druckt dieser Befehl die grafische Ansicht, die im Inhalts-Bereich dargestellt ist.
Wenn Sie eine Datei selektiert haben und der AppBrowser sich im Editor-Modus befindet (Die Registerkarte Quelltext ist ausgewählt), ruft der Befehl den Dialog Druckoptionen auf, wo Sie angeben können, wie die Datei ausgedruckt werden soll. Wenn Sie einen Textblock markiert haben, wird das Kontrollkästchen Markierten Block drucken aktiviert, das Sie in Abbildung 5.14 sehen. Sie können auch noch weitere Druckoptionen festlegen, beispielsweise, ob Sie Syntaxdruck, Farbe, Zeilennummern und Kopfbereich/Seitenzahlen ausgeben wollen, und ob lange Zeilen umbrochen (oder abgeschnitten) werden sollen.
Abbildung 5.14: Der Dialog Druckoptionen
Die Setup-Schaltfläche ruft den Dialog Drucker einrichten auf (siehe Abbildung 5.13).
Dieser Befehl beendet den JBuilder. Alle in der IDE geöffneten Dateien und Projekte werden geschlossen. Wenn es Dateien gibt, die noch nicht gespeichert wurden, fragt JBuilder Sie, ob Sie sie vor dem Schließen speichern wollen. Dazu wird der in Abbildung 5.15 angezeigte Dialog Geänderte Dateien speichern angezeigt. In diesem Dialog können Sie auswählen, welche Dateien gespeichert werden sollen, ob alle gespeichert werden sollen, oder ob gar keine gespeichert werden soll.
Abbildung 5.15: Der Dialog Geänderte Dateien speichern
Das Menü Bearbeiten enthält die Befehle zur Manipulation von Textblöcken im Editor des AppBrowsers und der Komponenten im Visual Designer. Unter anderem handelt es sich dabei um das übliche Ausschneiden/Kopieren/Einfügen, Rückgängig/Widerrufen und die Auswahlbefehle. Außerdem finden Sie dort einen Befehl zum Einfügen von Ausschnitten, vordefinierten Codeabschnitten, die Sie in Ihre Dateien einfügen können, um ein Menü, eine Hashtable oder ein Info-Feld zu erzeugen. Abbildung 5.16 zeigt das Bearbeiten-Menü.
Abbildung 5.16: Das Bearbeiten-Menü
Um Tastencodes rückgängig zu machen, die im Editor vorgenommen wurden, auch Cursorbewegungen, verwenden Sie diesen Befehl. Der Befehl Rückgängig kann beliebig oft wiederholt werden. Der Standardwert beträgt 32767mal.
Um eine Rückgängig-Operation rückgängig zu machen, verwenden Sie diesen Befehl wiederholt.
Dieser Befehl plaziert die ausgewählten Textblöcke oder Komponenten in der Zwischenablage und löscht sie aus der IDE.
Dieser Befehl plaziert die ausgewählten Textblöcke oder Komponenten in der Zwischenablage, ohne sie jedoch aus der IDE zu löschen.
Dieser Befehl fügt Textblöcke oder Komponenten aus der Zwischenablage in die IDE ein.
Dieser Befehl löscht die markierten Textblöcke oder Komponenten aus der IDE, ohne sie in der Zwischenablage zu plazieren.
Dieser Befehl markiert den gesamten Text im Editor oder selektiert alle Komponenten im Visual Designer.
Das Menü Suchen enthält die Befehle zum Suchen und Ersetzen von Text, zum Suchen von Text in mehreren Dateien entlang der Quellpfade, zur Positionierung des Cursors in einer bestimmten Zeile oder zur Anzeige von Codesymbolen. Abbildung 5.17 zeigt das Suchen-Menü.
Abbildung 5.17: Das Menü Suchen
Dieser Befehl zeigt den Dialog Text suchen an, den Sie in Abbildung 5.18 sehen.
Abbildung 5.18: Der Dialog Text suchen
Dieser Dialog ermöglicht Ihnen, den Textstring anzugeben, nach dem gesucht werden soll. Wenn im Editor Text markiert ist, erscheint er automatisch im Feld Suchen nach. Sie können auch Optionen für die Suche spezifizieren, etwa die Richtung, den Bereich, den Anfang oder die Berücksichtigung der Groß-/Kleinschreibung, ganze Wörter oder reguläre Ausdrücke.
Dieser Befehl zeigt den Dialog Text ersetzen an, den Sie in Abbildung 5.19 sehen.
Abbildung 5.19: Der Dialog Text ersetzen
Dieser Dialog ermöglicht Ihnen, einen Textstring anzugeben, nach dem gesucht werden soll, sowie einen Textstring, der dafür eingesetzt werden soll. Wenn im Editor Text markiert ist, wird dieser automatisch im Feld Suchen nach angezeigt. Neben den Optionen, die im Dialog zur Suche nach Text möglich sind, können Sie hier angeben, ob für jedes Ersetzen eine Bestätigung erfolgen soll, oder ob alle Vorkommen des Textes ohne Bestätigung ersetzt werden sollen.
Dieser Befehl wiederholt die letzte Suche, das Suchen und Ersetzen oder eine inkrementelle Suchoperation.
Dieser Befehl plaziert den Cursor direkt über den übereinstimmenden Text, wenn Sie einen Buchstaben eingeben.
Dieser Befehl sucht in allen im Quellpfad des Projekts angegebenen Dateien nach einem bestimmten Text (wie im Eigenschaften-Dialog ProjektName.jpr spezifiziert). Abbildung 5.20 zeigt den Dialog Quellpfad durchsuchen.
Abbildung 5.20: Der Dialog Quellpfad durchsuchen
Dieser Befehl zeigt den Dialog Zeilennummer an (Abbildung 5.21).
Abbildung 5.21: Der Dialog Zeilennummer
Dieser Dialog ermöglicht Ihnen, die Zeilennummer im Text anzugeben, in der der Cursor plaziert werden soll.
(Pro und C/S) Dieser Befehl zeigt den Durchsuchen Dialog an (Abbildung 5.22).
Abbildung 5.22: Der Durchsuchen Dialog
In diesem Dialog können Sie eine Klasse, Interface oder Package durchsuchen.
Die Befehle des Ansicht-Menüs aktivieren die IDE-Ansichten und Fenster bzw. schalten sie um. Außerdem können Sie Teile des Hauptfensters anzeigen oder verbergen. Abbildung 5.23 zeigt das Ansicht-Menü.
Abbildung 5.23: Das Ansicht-Menü
Um Ihnen einen besseren Überblick zu bieten, wie diese Fenster in der Regel aussehen, zeigen die meisten Abbildungen die Fenster im Kontext einer Debugging-Sitzung des Welcome-Projekts.
Dieses Fenster zeigt eine Liste aller Klassen an, die der aktuellen Klasse in der Debugging-Sitzung zugeordnet sind. Abbildung 5.24 zeigt ein Beispiel für dieses Fenster.
Abbildung 5.24: Das Fenster Geladene Klassen
Dieses Fenster zeigt alle Meldungen und Fehler an, die ein Programm während der Ausführung oder des Debuggings erzeugt, auch die Standardausgabe. Abbildung 5.25 zeigt ein typisches Beispiel.
Abbildung 5.25: Das Ausführungsprotokoll-Fenster
Dieses Fenster erzeugt für jede ausführbare Datei, die es erkennt, eine neue Registerkartenseite. Wenn Sie ein Programm mehrere Male ausführen, können Sie auf seine Seite zurückblättern, um die Ergebnisse früherer Ausführungen einzusehen. Die Seiten können mit Hilfe des Popup-Menüeintrags Seite entfernen entfernt werden.
Dieses Fenster zeigt eine Liste der Haltepunkte, die in der aktuellen Debugging-Sitzung gesetzt sind, wie in Abbildung 5.26 gezeigt.
Abbildung 5.26: Das Haltepunkte-Fenster
Dieses Fenster zeigt verschiedene Informationen über die aktuelle Debugging-Sitzung an, unter anderem Threads, Aufrufstack und Daten. Abbildung 5.27 zeigt ein Beispiel.
Abbildung 5.27: Das Fenster des Debugger-Kontext-Browser
Es ist möglich, mehrere Debugger-Kontext-Browser-Fenster gleichzeitig zu öffnen.
Dieser Befehl öffnet ein neues AppBrowser-Fenster. Sie können dann eine weitere Kopie desselben Projekts laden, so daß Sie zwei oder mehr Ansichten auf dieselben Dateien erhalten.
Dieser Befehl zeigt die nächste Fehlermeldung in der Meldungsanzeige an (die automatisch unten auf dem Inhalts-Bereich des AppBrowsers angezeigt wird, wenn ein Compiler-Fehler auftritt) und positioniert den Cursor im Editor in der Zeile, wo der Fehler aufgetreten ist.
Dieser Befehl zeigt die vorherige Fehlermeldung in der Meldungsanzeige an (die automatisch unten auf dem Inhalts-Bereich des AppBrowsers angezeigt wird, wenn ein Compiler-Fehler auftritt) und positioniert den Cursor im Editor in der Zeile, wo der Fehler aufgetreten ist.
Mit diesem Befehl wird die Meldungsanzeige im Inhalts-Bereich des AppBrowsers angezeigt bzw. verborgen. Wenn die Meldungsanzeige aktiv ist, befindet sich neben dem Befehl ein Häkchen als Markierung.
Dieser Befehl ist nur aktiv, wenn sich der AppBrowser im Visual Designer-Modus befindet. (Mehr darüber erfahren Sie in der nächsten Lektion.). Wenn das Fenster für den Komponenten-Inspektor geschlossen wurde, können Sie diesen Befehl verwenden, um es wieder zu öffnen. Abbildung 5.28 zeigt den Komponenten-Inspektor (siehe Abbildung 5.28).
Abbildung 5.28: Der Komponenten-Inspektor
Dieser Befehl zeigt die Symbolleiste im Hauptfenster an bzw. verbirgt sie. Wenn Sie die Symbolleiste nicht häufig verwenden, oder wenn Sie mehr Platz auf dem Hauptfenster brauchen, um die Komponentenpalette anzuzeigen, verwenden Sie diesen Befehl. Wenn die Symbolleiste angezeigt wird, ist der Befehl an der linken Seite mit einem Häkchen markiert.
Mit diesem Befehl zeigen Sie die Komponentenpalette im Hauptfenster an oder verbergen diese. Dieser Befehl ist an der linken Seite mit einem Häkchen markiert, wenn die Komponentenpalette angezeigt wird.
Dieser Befehl veranlaßt, daß der Inhalts-Bereich des AppBrowsers das gesamte AppBrowser-Fenster einnimmt, oder daß sein Standardzustand wiederhergestellt wird (mehrere Bereiche werden angezeigt). Dieser Befehl ist an der linken Seite markiert, wenn mehrere AppBrowser-Bereiche angezeigt werden.
Dieser Bereich setzt den Fokus auf den nächsten Bereich im AppBrowser. Die Reihenfolge ist Navigations-Bereich, Struktur-Bereich, Inhalts-Bereich und Meldungsansicht.
Die Befehle im Projekt-Menü erzeugen einzelne Dateien und ganze Projekte. Abbildung 5.29 zeigt das Projekt-Menü.
Abbildung 5.29: Das Projekt-Menü
Die Aktualisieren-Befehle führen eine bedingte Kompilierung aus, während die Neu-Erstellen-Befehle eine unbedingte Kompilierung vornehmen. Das Neu erstellen ist insbesondere dann sinnvoll, wenn Sie bereit sind, Ihre Anwendung auszuliefern und das ganze Projekt ohne Debugging-Informationen neu erstellen wollen.
Dieser Befehl kompiliert alle Quelldateien des aktuellen Projekts, für die es entweder keine .class-Datei gibt, oder die neuer als ihre .class-Datei sind.
Dieser Befehl kompiliert alle Quelldateien des aktuellen Projekts, egal ob sie eine aktuelle .class-Datei haben oder nicht. Außerdem bewirkt dieser Befehl, daß alle importierten Dateien und Pakete rekursiv kompiliert werden (außer den Standardpaketen java und jbcl).
Dieser Befehl kompiliert die aktuell selektierte Quelldatei, wenn es für sie keine .class-Datei gibt, oder wenn sie neuer ist als ihre .class-Datei.
Dieser Befehl kompiliert die aktuell selektierte Quelldatei im Projekt, egal ob es eine aktuelle .class-Datei gibt oder nicht.
Das Menü Start enthält die Befehle zum Ausführen und Debuggen Ihrer Anwendung aus der IDE und für den Zugriff auf die Debugging-Ansichten. Abbildung 5.30 zeigt das Start-Menü (siehe Abbildung 5.30).
Abbildung 5.30: Das Start-Menü
Die Menüeinträge werden aktiviert oder deaktiviert dargestellt, abhängig davon, ob Sie sich in einer Debugging-Sitzung befinden und in welcher Phase diese Sitzung gerade verläuft.
Dieser Befehl startet eine Debugging-Sitzung in der IDE. Alle veränderten Projektdateien werden kompiliert, bevor die Ausführung beginnt.
Dieser Befehl führt Ihre Anwendung in der IDE aus. Alle veränderten Projektdateien werden kompiliert, bevor die Ausführung beginnt.
Dieser Befehl zeigt die Start/Debug-Seite des Eigenschaften-Dialogs ProjektName.jpr an (siehe Abbildung 5.12). Dort können Sie Befehlszeilenoptionen angeben, die bei der Ausführung Ihrer Anwendung in der IDE verwendet werden.
Dieser Befehl führt einen Prozeduraufruf, seine Anweisungen und seine Rückgabe beim Debugging in einem einzigen Schritt aus.
Dieser Befehl führt einen Prozeduraufruf, seine Anweisungen und seine Rückgabe beim Debugging als Einzelschritte aus.
Dieser Befehl führt Ihre Anwendung beim Debugging aus, bis er die aktuelle Cursorposition im Code findet.
Dieser Befehl führt Ihre Anwendung beim Debugging aus, bis er das Ende der aktuellen Methode im Code erreicht hat.
Dieser Befehl positioniert den Debugging-Cursor in der Zeile, die beim Debugging als nächstes ausgeführt werden soll.
Dieser Befehl unterbricht die Ausführung Ihrer Anwendung, während sie beim Debugging in der IDE ausgeführt wird.
Dieser Befehl entlädt die Anwendung, die aktuell in der IDE geladen ist.
Dieser Befehl zeigt den Dialog Ausdruck hinzufügen an, den Sie in Abbildung 5.31 sehen.
Abbildung 5.31: Der Dialog Ausdruck hinzufügen
In diesem Dialog können Sie spezifizieren, welchen Ausdruck Sie beobachten wollen. Diese Ausdrücke werden auf der Ausdruck-Seite des Debugging-Fensters angezeigt.
Dieser Befehl zeigt den Dialog Haltepunktoptionen an, wo Sie einen existierenden Haltepunkt ändern oder einen neuen Haltepunkt setzen können. Wenn der Typ Haltepunkt ist, wird die Definition-Seite angezeigt (Abbildung 5.32).
Abbildung 5.32: Der Dialog Haltepunktoptionen mit der Definition-Seite
Auf dieser Definition-Seite können Sie Optionen für den Haltepunkt angeben, unter anderem den Dateinamen, die Zeilennummer, die Anzahl der Durchgänge und die Thread-Optionen. Wenn der Haltepunkt ein Exception-Haltepunkt ist, wird eine andere Definition-Seite angezeigt (Abbildung 5.33).
Abbildung 5.33: Der Dialog Haltepunkte für Exception-Haltepunkte
Auf dieser Definition-Seite werden die Optionen für Dateiname und Zeilennummer durch Optionen ersetzt, die dem Debugger mitteilen, für welche Art Ausnahme der Haltepunkt die Ausnahme unterbrechen soll.
Abbildung 5.34: Der Dialog Haltepunktoptionen, Aktion-Seite
Auf der Aktion-Seite (die für normale und Exception-Haltepunkte gleich ist) können Sie angeben, welche Aktion oder welche Aktionen ausgeführt werden sollen, wenn der Haltepunkt erreicht ist (Abbildung 5.34).
Dieser Befehl zeigt den Überprüfen-Dialog an (Abbildung 5.35).
Abbildung 5.35: Der Dialog Überprüfen
In diesem Dialog können Sie einen Ausdruck spezifizieren, der überprüft werden soll. Sowohl der Ausdruck als auch sein aktueller Wert werden angezeigt und der Wert wird bei der Fortsetzung der Debugging-Sitzung aktualisiert.
Dieser Befehl zeigt den Dialog Auswerten/Ändern an (Abbildung 5.36).
Abbildung 5.36: Der Dialog Auswerten/Ändern
Dieser Dialog ermöglicht Ihnen, Werte oder Eigenschaften während des Debuggings auszuwerten oder vorübergehend zu ändern.
(Pro und C/S) Das Experten-Menü ruft verschiedene Hilfs-Utilities auf, die Ihnen Fragen hinsichtlich der Aufgabe stellen, und Ihnen dann ein neues Projekt präsentieren, das alle ausgewählten Elemente enthält. Abbildung 5.37 zeigt das Experten-Menü.
Abbildung 5.37: Das Experten-Menü
Dieser Experte hilft Ihnen, eine Schnittstellen-Klasse zu erzeugen. Abbildung 5.38 zeigt den ersten Dialog dieses Experten.
Abbildung 5.38: Der erste Dialog des Experten für die Schnittstellenimplementierung
Dieser Experte verbindet Ereignisse mit Komponenten. Abbildung 5.39 zeigt den ersten Dialog des Experten.
Abbildung 5.39: Der erste Dialog des Interaktions-Experten
Dieser Experte ermöglicht Ihnen, eine Methode aus der Oberklasse auszuwählen, die Sie überschreiben wollen. Aus dieser Methode erzeugt der Experte eine leere Methode in Ihrem Quellcode, in die Sie Ihren Code eingeben können. Abbildung 5.40 zeigt den ersten Dialog dieses Experten.
Abbildung 5.40: Der Experte zum Überschreiben von Methoden
Dieser Experte hilft Ihnen hart-codierte Strings aus Ihrem Programm in Bezeichner umzuwandeln und stellt Ihnen dann die Zuordnungen zwischen Name und String in einer Ressourcendatei zur Verfügung. Abbildung 5.41 zeigt den ersten Dialog dieses Experten.
Abbildung 5.41: Der erste Dialog des Experten Strings in Ressource
Dieser Experte hilft Ihnen, ein Applet in eine JavaBean umzuwandeln. Abbildung 5.42 zeigt den ersten Dialog dieses Experten.
Abbildung 5.42: Der erste Dialog des Experten In Komponente umwandeln
Dieser Experte hilft Ihnen, die Dateien zusammenzustellen, die Sie für die Weitergabe Ihrer Anwendung oder eines Applets im Web brauchen, und erzeugt außerdem komprimierte Java-Archivdateien (.jar). Abbildung 5.43 zeigt den ersten Dialog dieses Experten.
Abbildung 5.43: Der Weitergabe-Experte
Das Tools-Menü enthält die Befehle zur Konfiguration der Komponentenpalette und der IDE sowie einige andere Utilities. Abbildung 5.44 zeigt das Tools-Menü.
Abbildung 5.44: Das Tools-Menü
Dieser Befehl zeigt den Dialog Paletteneigenschaften an, wo Sie Seiten und Komponenten der Palette hinzufügen, entfernen und neu anordnen können. Dieser Dialog wird detailliert in Lektion 7 beschrieben.
Dieser Befehl zeigt den Dialog Umgebungsoptionen an, der sich aus fünf Seiten zusammensetzt: Compiler, Editor, Anzeige, Farben und AppBrowser. Auf diesen Seiten können Sie Ihre Arbeitsumgebung Ihrem persönlichen Geschmack anpassen. Durch die Abänderung verschiedener Umgebungsoptionen können Sie Ihre Entwicklungsumgebung auf Ihre Bedürfnisse abstimmen. Bestimmte Optionen, wie etwa die Hervorhebung der Syntax, kann außerdem helfen, Fehler frühzeitig zu erkennen. Andere Optionen steuern, ob bestimmte Informationen zwischen den einzelnen Projektsitzungen gespeichert werden sollen. Wieder andere Optionen bestimmen das Erscheinungsbild der IDE-Fenster, etwa die AppBrowser-Optionen.
Die Compiler-Seite (Abbildung 4.45) ist Ihnen vielleicht vertraut - sie entspricht dem Eigenschaften-Dialog ProjektName.jpr, allerdings mit einer wichtigen Ausnahme. Die Pfade und Optionen sind Standardwerte für alle neuen Projekte. Die Information aus diesem Dialog wird aktualisiert, wenn Sie im Eigenschaften-Dialog ProjektName.jpr die Schaltfläche Vorgabe anklicken.
Abbildung 5.45: Der Dialog Umgebungsoptionen, Compiler-Seite
Auf der Seite mit den Editor-Optionen können Sie anpassen, wie Ihr Editor Text verarbeitet, unter anderem Tabulatoren, Blöcke überschreiben oder ob für bestimmte Dateien die Syntax hervorgehoben dargestellt werden soll. Die Option Editor-Schnelleinstellung setzt automatisch bestimmte Editor-Optionen und steuert außerdem die Standardvorgaben für zwei Optionen auf der Anzeige-Seite (BRIEF Cursorform und Tastaturbelegung). Sie können einzelne Optionen auch anders setzen als in der Schnelleinstellung vorgegeben. Wenn Sie das tun und später die Vorgaben wieder einstellen wollen, selektieren Sie einfach wieder die alte Schnelleinstellung. Abbildung 5.46 zeigt die Editor-Seite mit den vorinstallierten Standardwerten.
Abbildung 5.46: Der Dialog Umgebungsoptionen, Editor-Seite
Auf der Anzeige-Seite der Umgebungsoptionen setzen Sie verschiedene Eigenschaften, die sich ebenfalls auf den Editor beziehen. Einige bestimmen, wie das Editor-Fenster angezeigt wird, wie etwa der rechte Rand, ob er sichtbar dargestellt werden soll, die Schrift sowie Cursorformen. Andere Optionen legen fest, ob Backup-Dateien erzeugt werden, und welche Tastaturbelegung verwendet wird (hier wird angegeben, welche Tastaturabkürzungen aktiv sind).
Außerdem können Sie auf dieser Seite festlegen, wie der Editor maximiert wird: ob er den gesamten Bildschirm einnimmt, oder nur den Platz unterhalb des Hauptfensters von JBuilder. Abbildung 5.47 zeigt die Anzeige-Seite, so wie sie vorinstalliert ist.
Abbildung 5.47: Der Dialog Umgebungsoptionen, Anzeige-Seite
Auf der Farben-Seite der Umgebungsoptionen bestimmen Sie, wie die Farbdarstellung der Syntax aussehen soll. Dabei können auch Schriftattribute für bestimmte Codeelemente angegeben werden. Für jedes Codeelement kann ein separater Stil ausgewählt werden, etwa für Kommentare oder Bezeichner. Die hervorgehobene Darstellung der Syntax bietet Ihnen eine schnelle Möglichkeit, Fehler zu erkennen, und macht Ihren Code leichter lesbar. Das Erscheinungsbild Ihrer Codeausgaben wird durch diese Einstellungen ebenfalls beeinflußt, sofern Ihr Drucker die Textattribute und Farben unterstützt.
Das scrollbare Fenster für den Beispieltext zeigt die Auswahlen, die auf dieser Seite vorgenommen werden, kann aber auch verwendet werden, um ein Codeelement auszuwählen. Klicken Sie beispielsweise auf die erste Zeile, die einen Kommentar enthält. Beachten Sie, wie die Optionen aktualisiert werden, um Ihre Auswahl zu reflektieren. Dadurch können Sie ganz einfach ein Codeelement auswählen, um seine Einstellungen zu überprüfen, ohne wissen zu müssen, wie dieses Element heißt. Abbildung 5.48 zeigt die Farben-Seite mit vorinstallierten Standardwerten.
Abbildung 5.48: Der Dialog Umgebungsoptionen, Farben-Seite
Die AppBrowser-Seite der Umgebungsoptionen ermöglicht Ihnen, das Verhalten des AppBrowsers zu konfigurieren. Auf dieser Seite können Sie die Sortierreihenfolge nach Zugriffs-Modifier und Strukturtyp bestimmen. Die Optionen für die Gruppierung bestimmt, wie Datenelemente und Methoden angezeigt werden, und ob Elemente der Sichtbarkeit nach gruppiert werden. Außerdem können Sie steuern, wie die Elemente sortiert werden, sowohl nach der Struktur als auch nach dem Zugriff. Man kann festlegen, ob beim Starten der IDE das Projekt geladen werden soll, das zuletzt bearbeitet wurde. Abbildung 5.49 zeigt die AppBrowser-Seite mit den vorinstallierten Standardwerten.
Abbildung 5.49: Der Dialog Umgebungsoptionen, AppBrowser-Seite
Dieser Befehl ruft das Notepad-Programm von Windows auf.
Dieser Befehl ruft das Rechner-Programm von Windows auf.
Dieser Befehl zeigt einen Dialog an (Abbildung 5.50), in dem Sie die Dateitypen ergänzen können, die JBuilder als Textdateien betrachtet.
Abbildung 5.50: Der Dialog Als Text behandeln
Dieser Befehl zeigt den ersten der drei Dialoge des Interaktions-Experten-Editors an (Abbildung 5.51), wo Sie die Komponenten anpassen können, die im Interaktions-Experten bereitgestellt werden, wenn er im Experten-Menü ausgewählt wird.
Abbildung 5.51: Der Dialog für den Interaktions-Experten-Editor
Dieser Befehl zeigt einen Dialog an (Abbildung 5.52), der Ihnen ermöglicht, die Web-Seite von Borland nach Aktualisierungen oder Ergänzungen zu durchsuchen. Außerdem können Sie hier einstellen, daß Sie monatlich erinnert werden wollen, die Web-Seite anzusehen.
Abbildung 5.52: Der Dialog JBuilder Web-Updates
Das Hilfe-Menü enthält Befehle, mit denen Sie auf die Hilfe und die Dokumentation von JBuilder zugreifen, BeansExpress ausführen, auf Borland Online zugreifen und das Info-Feld anzeigen können. Abbildung 5.53 zeigt das Hilfe-Menü.
Abbildung 5.53: Das Hilfe-Menü
Dieser Befehl lädt das JBuilder-Hilfesystem mit der Online-Dokumentation des JBuilder.
Dieser Befehl lädt das JBuilder-Hilfesystem mit der JavaBeans-Express-Dokumentation. Dort wird erklärt wie, die BeansExpress-Objekte verwendet werden.
Dieser Befehl lädt das JBuilder-Hilfesystem mit der Java-Dokumentation von Sun.
Dieser Befehl lädt das JBuilder-Hilfesystem mit der Bibliotheks-Dokumentation für die JBCL (JavaBeans Component Library).
Dieser Befehl öffnet Ihren Standard-Web-Browser mit der URL der Web-Seite von Borland und gibt Ihnen damit direkten Zugriff auf Borland Online von der IDE aus.
Dieser Befehl öffnet das Beispielprojekt im AppBrowser.
Dieser Befehl zeigt das Info-Feld des JBuilder an.
Die Elemente, aus denen sich die Object Gallery zusammensetzt, werden im Neu-Dialog angezeigt, das Sie durch die Auswahl von Datei | Neu aufrufen. Dieser Dialog besteht aus sieben Seiten: Neu, Bedienfelder, Menüs, Dialoge, Datenmodule, BeansExpress und Andere.
Um die Elemente der Object Gallery zu verwenden, klicken Sie entweder auf das betreffende Element und klicken auf die OK-Schaltfläche, oder Sie doppelklicken einfach auf das Element, und los geht's! Sie können auch eigene Komponenten, Container und Code-Abschnitte einfügen, indem Sie mit der rechten Maustaste auf die entsprechende Seite klicken und im Popup-Menü den Eintrag Bausteine hinzufügen auswählen.
Die Seite Neu (Abbildung 5.54) enthält mehrere Dateitypen, unter anderem: Anwendung, Applet, Projekt, Frame, Dialog, Bedienfeld, Datenmodul, Klasse und Html. Durch die Auswahl eines dieser Dateitypen weisen Sie die IDE an, eine Gerüst-Quellcodedatei dieses Typs anzulegen und im AppBrowser anzuzeigen.
Die Anwendung-, Applet- und Projekt-Dateien werden erzeugt, indem Sie einen Experten aufrufen, der Sie nach Informationen über die vorliegende Aufgabe abfragt und den Quellcode basierend auf Ihren Antwort anlegt.
Die Frame-, Dialog-, Bedienfeld-, Datenmodul- und Klassen-Dateien werden erzeugt, indem ein zweiter Dialog aufgerufen wird, der Sie nach dem Paket des Elements, dem Klassennamen und dem Dateinamen fragt, bevor der entsprechende Code angelegt wird. Hier eine kurze Erklärung der einzelnen Dateitypen:
Das Html-Element erzeugt ein Gerüst für eine .html-Datei und plaziert den Quellcode direkt im Inhalts-Bereich des AppBrowsers.
Die Bedienfelder-Seite (Abbildung 5.55) bietet Ihnen Zugriff auf vordefinierte Quellcodeabschnitte, mit deren Hilfe Sie schnell und einfach standardisierte Fenster erzeugen können:
Abbildung 5.55: Die Bedienfelder-Seite
Die Menüs-Seite (Abbildung 5.56) bietet Ihnen Zugriff auf einen vordefinierten Quellcode-Abschnitt, der Ihnen ermöglicht, Ihrem Projekt ein standardisiertes Menü hinzuzufügen.
Abbildung 5.56: Die Menüs-Seite
Die Dialoge-Seite (Abbildung 5.57) bietet Ihnen Zugriff auf vordefinierte Code-Abschnitte, die es Ihnen ermöglichen, Ihrem Projekt standardisierte Dialoge hinzuzufügen:
Abbildung 5.57: Die Dialoge-Seite
Die Datenmodule-Seite (Abbildung 5.58) enthält einen vordefinierten Code-Abschnitt, der Ihnen ermöglicht, eine Verbindung zur Beispieldatenbank Angestelltendaten. Mit Hilfe dieses Codes können Sie eine Schablone anlegen, mit der Sie auch Verbindungen zu anderen Datenbanken einrichten.
Abbildung 5.58: Die Datenmodul-Seite
Die BeansExpress-Seite (Abbildung 5.59) enthält vordefinierte Codeabschnitte, die Ihnen Beispiele bereitstellen, anhand derer Sie eigene JavaBean-Komponenten erzeugen können.
Abbildung 5.59: Die BeansExpress-Seite
Genauere Informationen über diese Elemente finden Sie durch die Auswahl von Hilfe | BeansExpress im der Haupt-Menüleiste der IDE. Hier eine kurze Beschreibung der einzelnen Elemente:
Die Andere-Seite (Abbildung 5.60) kann genutzt werden, um verschiedene Codeabschnitte zu sammeln, die Sie wiederverwenden wollen. Durch die Auswahl des Beispielbaustein-Objekts auf dieser Seite erhalten Sie einen zweiten Dialog, in dem Sie die Teile des Codes auswählen können, die Sie in Ihr Programm einfügen wollen.
Abbildung 5.60: Die Andere-Seite
Die Symbolleiste bietet Ihnen Zugriff auf die 14 gebräuchlichsten Befehle des JBuilders. Die Befehle werden an einer leicht zugänglichen Stelle bereitgestellt, nämlich im Hauptfenster als Icons.
Abbildung 5.61 zeigt die Symbolleiste, wie sie nach der Installation im Hauptfenster von JBuilder erscheint.
Abbildung 5.61: Die Symbolleiste
Um zu sehen, welche Aufgabe ein Icon der Symbolleiste hat, schieben Sie den Mauszeiger über
das Icon, dann erscheint ein Tooltip mit dem Namen des betreffenden Befehls.
Sie können die Größe der Palette im Hauptfenster anpassen, indem Sie die Maus über die Trennlinie zwischen Symbolleiste und Komponentenpalette schieben diese in die gewünschte Richtung ziehen. Wenn Sie die Komponentenpalette nicht anzeigen, erstreckt sich die Symbolleiste über die gesamte Breite des Hauptfensters und bietet viel freien Platz, wo Sie neue Icons hinzufügen können. Mit dem Befehl Ansicht | Symbolleiste Sie können die Symbolleiste auch verbergen.
JBuilder enthält Java- und JavaBean-Komponenten, die über die Komponentenpalette bereitgestellt werden. Die Komponentenpalette befindet sich im Hauptfenster von JBuilder. Es handelt sich dabei um mehrere Registerkartenseiten mit Icons, die die jeweiligen JBuilder-Komponenten darstellen. Neben den Komponenten von JBuilder können Sie auch eigene oder gekaufte Komponenten hier ablegen.
Die Komponentenpalette präsentiert Ihnen Seiten mit Java-, JavaBean- und Beispiel-Komponenten (die letzteren, damit Sie selbst Komponenten erzeugen können). Beispiele für ihre Verwendung finden Sie in Lektion 7. Als Einführung wird hier jedoch jede Komponentenseite kurz beschrieben.
Wenn Sie den Mauszeiger kurz über eine Komponente schieben, wird ein Tooltip angezeigt, der
den vollständigen Klassennamen dieser Komponente anzeigt. Nachdem Sie den Namen kennen, können Sie
im Hilfe-Menü weitere Informationen über die Komponente ermitteln.
Sie können die Größe der Palette im Hauptfenster ändern, indem Sie die Maus über die Trennlinie zwischen Komponentenpalette und Symbolleiste schieben und diese dann in die gewünschte Richtung ziehen. Wenn Sie die Symbolleiste verbergen, erstreckt sich die Komponentenpalette über die gesamte Breite des Hauptfensters. Mit dem Befehl Ansicht | Komponentenpalette können Sie die Palette ganz verbergen.
Wenn eine Palettenseite nicht breit genug ist, um alle ihre Komponenten anzuzeigen, können Sie sie mit Hilfe der beiden großen Pfeile links und rechts scrollen. Wenn der Bereich für die gesamte Palette nicht groß genug ist, um alle Registerkarten anzuzeigen, werden ebenfalls Pfeile angezeigt, mit deren Hilfe Sie scrollen können.
Die Steuerelemente-Seite (Abbildung 5.62) enthält die JavaBeans, die in der JBuilder-Klassenbibliothek (JBCL) definiert sind, etwa Beschriftungen, Schaltflächen, Bildlaufleisten oder Kontrollkästchen. Diese Steuerelemente sind in der Klasse jbcl.control definiert und können über die Datenzugriff-Seite mit Datenbanken verbunden werden.
Abbildung 5.62: Die Steuerelemente-Seite
Die Container-Seite (Abbildung 5.63) enthält JavaBean-Komponenten, die Container sind (Fenster und Gruppenfelder), und die andere Komponenten aufnehmen können. Diese Komponenten sind in der Klasse jbcl.control definiert.
Abbildung 5.63: Die Container-Seite
Diese AWT-Seite (Abbildung 5.64) enthält Komponenten, die Standard-Grafiksteuerelemente aus der Klasse java.awt darstellen, wie etwa Beschriftungen, Schaltflächen, Bildlaufleisten oder Kontrollkästchen. Diese Steuerelemente können nicht mit Datenbanken verknüpft werden.
Die Dialoge-Seite (Abbildung 5.65) enthält JavaBean-Komponenten, die nicht-visuelle Steuerelemente darstellen, welche beim Aufruf Standarddialoge anzeigen, etwa zur Auswahl von zu öffnenden Dateien, Farben, Schriftarten oder Meldungen. Diese Dialoge sind in der Klasse jbcl.control definiert.
Abbildung 5.65: Die Dialoge-Seite der Komponentenpalette
Die Datenzugriff-Seite (Pro und C/S), die Sie in Abbildung 5.66 sehen, enthält JavaBean-Komponenten, die Steuerelemente für den Datenbankzugriff darstellen. Sie sind in der Klasse jbcl.dataset definiert.
Abbildung 5.66: Die Datenzugriff-Seite
Die Sun-Applets-Seite (Abbildung 5.67) enthält JavaBeans-Komponenten, die als Beispiele für Komponenten bereitgestellt werden, die Sie selbst erzeugen können, indem Sie Applets in JavaBeans einhüllen. Diese Komponenten sind in einzelnen Unterpaketen von jbcl.appletwrappers definiert.
Abbildung 5.67: Die Sun-Applets-Seite
Die KL-Gruppe-Seite (Abbildung 5.68) enthält JavaBean-Komponenten von einem Dritthersteller (KL Group, Toronto, Ontario, Kanada). Weitere Informationen über diese Komponenten finden Sie in der Hilfe von JBuilder.
Abbildung 5.68: Die KL-Gruppe-Seite
Die Andere-Seite wird für Sie bereitgestellt, damit Sie dort Ihre eigenen Komponenten oder die von Drittherstellern gekauften Komponenten unterbringen können. Sie ist nach der Installation noch leer.
Im AppBrowser erledigen Sie einen Großteil der Arbeit in der IDE: Sie erzeugen Dateien und fügen sie Projekten hinzu, Sie bearbeiten und debuggen Quellcode und Sie strukturieren Ihr Programm. Abbildung 5.69 zeigt den AppBrowser mit dem Welcome-Projekt im Debug-Modus.
Abbildung 5.69: Das AppBrowser-Fenster
Der Modus wird mit Hilfe der Registerkarten unten links gewählt. Der AppBrowser kennt fünf Modi: Projekt, Geöffnet, Ordner, Debug und Anzeige.
In Abbildung 5.69 werden in den Modus-Registerkarten ein Icon und ein Text angezeigt. Diese
Anzeige ist abhängig davon, wieviel Platz Sie haben. Wenn Sie das Icon und den Text sehen wollen, ändern
Sie die Größe der Bereiche, indem Sie Ihre Maus über die Trennlinie zwischen der linken und rechten
»Hälfte« des AppBrowsers und ziehen sie in die gewünschte Richtung. Wenn die Felder sehr klein gemacht
werden, wird mindestens das Icon angezeigt.
In jedem Modus ändern die Bereiche auf der linke Seite ihre Anzeigeinformation gemäß dem Kontext, wie später in diesem Abschnitt noch beschrieben wird.
Der Inhalts-Bereich auf der rechten Seite ist immer sichtbar. Er hat eigene Registerkarten, die steuern, wie die Information im Inhalts-Bereich angezeigt wird. Dabei handelt es sich um Quelltext, Design, Doku und Ansicht. Sie erscheinen je nach dem im AppBrowser angezeigten Kontext.
Wenn ein Element ausgewählt ist, für das es eine Textdarstellung gibt, wie etwa eine .java- oder eine .html-Datei, erscheint die Quelltext-Registerkarte. Die Auswahl dieser Registerkarte zeigt den Text im Inhalts-Bereich an, der zum Editor wird.
Wenn es für das ausgewählte Element einen Entwurf einer Benutzeroberfläche gibt, erscheint die Registerkarte Design. Der AppBrowser wird dadurch zum Visual Designer, der später in diesem Kapitel noch vorgestellt wird.
Die Doku-Registerkarte erscheint, wenn es für das ausgewählte Element eine entsprechende HTML-Dokumenationsdatei gibt, wie sie etwa mit dem Utility javadoc erzeugt werden kann. (javadoc extrahiert Dokumentationskommentare aus Ihren Dateien und erzeugt daraus automatisch eine HTML-Datei für Sie.) Wenn die javadoc-HTML-Datei erzeugt wurde, wird sie im Inhalts-Bereich angezeigt, andernfalls wird eine entsprechende Meldung angezeigt.
Wenn es für das ausgewählte Elemente eine visuelle Darstellung gibt, wie etwa eine GIF-, JPEG- oder HTML-Datei, wird die Registerkarte Ansicht angezeigt. Bei Auswahl dieser Registerkarte wird diese Grafik in dem Inhalts-Bereich angezeigt.
Eine weitere Funktion des Inhalts-Bereichs ist, daß Sie Ihn umschalten können, so daß er das gesamte AppBrowser-Fenster einnimmt. Dazu verwenden Sie entweder die Tastenkombination Alt+Z oder den Befehl Ansicht | Zoom. Das kann sehr praktisch sein, wenn Sie mit großen Grafiken arbeiten oder die Benutzeroberfläche entwerfen.
Wenn sich der AppBrowser im Projektbrowser-Modus befindet, erscheinen drei Bereiche: Der Navigations-Bereich, der Struktur-Bereich und der Inhalts-Bereich. Der Inhalts-Bereich kann noch einen weiteren Bereich beinhalten, die Meldungsanzeige, wo Meldungen über Compiler-Fehler angezeigt werden.
Der Navigations-Bereich befindet sich oben links im Projektbrowser. Dieser Bereich zeigt einen Baum dar, der die einzelnen Komponenten des aktuellen Projekts darstellen. Wenn einer der Knoten in diesem Bereich selektiert wird, werden die beiden anderen Bereich entsprechend aktualisiert. Abbildung 5.70 zeigt, wie im Navigations-Bereich die Datei WelcomeFrame.java selektiert ist.
Abbildung 5.70: Der AppBrowser im Projektbrowser-Modus
Der Struktur-Bereich befindet sich unten links im AppBrowser. Er zeigt die Struktur des aktuell im Navigations-Bereich selektierten Elements an. Diese Baumstruktur zeigt alle Klassen, Objekte, Methoden, Ressourcen und Importdateien an, aus denen sich der aktuelle Knoten des Projekts zusammensetzt. Die Auswahl einer dieser Strukturen bewirkt, daß ihr Inhalt im Inhalts-Bereich angezeigt wird. Abbildung 5.70 zeigt die Struktur der Datei WelcomeFrame.java, wobei die Methode jbInit() ausgewählt ist.
Der Inhalts-Bereich befindet sich rechts im AppBrowser. Was in diesem Bereich angezeigt wird, hängt davon ab, welche Knoten in den Navigations- und Struktur-Bereichen ausgewählt sind. Wenn im Navigations-Bereich eine .java-Datei ausgewählt ist, zeigt der Inhalts-Bereich die Datei an und wird gemäß der im Struktur-Bereich ausgewählten Struktur positioniert. In Abbildung 5.70 ist im Navigations-Bereich die Datei WelcomeFrame.java ausgewählt, deshalb wird ihr Text (Quellcode) im Inhalts-Bereich angezeigt. Weil im Struktur-Bereich die Methode jbInit() ausgewählt ist, wird diese Methode im Inhalts-Bereich hervorgehoben dargestellt.
Wenn eine .java-Datei angezeigt wird, wird der Inhalts-Bereich zum Editor. Die Seite enthält den Quellcode für Ihr Programm und seine Methoden im Textformat. Neben dem Code, den Sie manuell einfügen, gibt es auch zahlreiche Möglichkeiten, Code automatisch erzeugen und einfügen zu lassen. Durch die Änderung der Benutzeroberfläche im Visual Designer wird die Two-Way-Eigenschaft aktiviert und der Quellcode für das visuelle Element wird automatisch eingefügt.
Der Editor stellt Befehle zum Bearbeiten, zur Syntaxhervorhebung sowie zum Suchen und Ersetzen bereit. Wenn die Editor-Seite aktiv ist, wird unten im Inhalts-Bereich ein Feld angezeigt, das Statusinformationen enthält: Zeile:Spalte, Geändert und Überschreiben/Einfügen.
Wenn sich der AppBrowser im Modus Geöffnete Dateien befindet, der durch Anklicken der Registerkarte Geöffnet aktiviert wird, zeigt der Navigations-Bereich die Dateien an, die Sie während dieser Sitzung geöffnet haben. Diese Dateien müssen nicht unbedingt Teil des Projekts sein, und Sie können Dateien hinzufügen oder entfernen, ohne den Projektinhalt zu beeinflussen. Wenn Sie im AppBrowser eine Datei bearbeiten, wird sie automatisch in die Geöffnet-Seite eingetragen. Sie können der Geöffnet-Seite auch Dateien hinzufügen, indem Sie sie von anderen Ansichten auf den Bereich verschieben.
Wenn sich der Browser im Modus Geöffnete Dateien befindet, zeigt der Struktur-Bereich die Struktur der im Navigations-Bereich selektierten Datei an, und der Inhalts-Bereich zeigt den Inhalt der ausgewählten Datei an. Wenn es für die Datei eine Textdarstellung gibt, ist die Quelltext-Registerkarte ein Editor.
Wenn Sie auf die Registerkarte Ordner klicken, versetzen Sie den AppBrowser in den Ordner-Modus, so daß die Verzeichnisbäume des Festplattenlaufwerks der Maschine im Navigations-Bereich angezeigt werden. Damit haben Sie einfachen Zugriff auf die Dateien, die Sie Ihrem Projekt hinzufügen wollen, oder auf geöffnete Dateien. Die Struktur- und Inhalts-Bereiche haben in diesem Modus dieselbe Funktionalität wie im Projektbrowser-Modus um im Modus Geöffnete Dateien.
Wenn Sie Ihr Programm debuggen wollen, bietet Ihnen der AppBrowser Debugging-Ansichten. Mit Hilfe des integrierten Debuggers führen Sie Ihr Programm schrittweise aus. Wenn das Programm unterbrochen ist, haben Sie Zugriff auf mehrere Ansichten, die Ihnen ermöglichen, die Werte von Variablen zu ermitten und zu ändern und den Status von Objekten festzustellen.
Im Debug-Modus (Abbildung 5.69) ist der Bereich oben links der Threads- und Stack-Bereich, wo Threads, Methoden und Parameter aufgelistet werden, die bisher in der Programmausführung benötigt wurden. Der Bereich unten links ist der Datenbereich, woe Sie den Status der Daten eines Objekts einsehen können. Der Inhalts-Bereich zeigt den Quellcode an, aber jetzt werden die Ausführungszeilen durch einen Punkt im linken Rand des Editors angezeigt, und ein Pfeil zeigt die aktuelle Ausführungszeilen an.
Im Ansicht-Modus zeigt das linke Feld die Bezeichner oder die Ausdrücke an, die Sie auswerten wollen, wenn sie sich während der Ausführung Ihrer Anwendung ändern. Diese Ausdrücke können mit Hilfe des Befehls Start | Ausdruck hinzufügen gesetzt werden. Der Inhalts-Bereich sieht dann aus wie im Debug-Modus.
Die Debugging-Ansichten umfassen den AppBrowser im Debug-Modus (Thread- und Stack-Bereich, Datenbereich und Inhalts-Bereich), das Haltepunkt-Fenster und den Inspektor und die Auswerten/Ändern-Dialoge. Detailliertere Informationen darüber erhalten Sie in Lektion 11.
Um den Visual Designer aufzurufen, wählen Sie einen Frame-Knoten im Navigations-Bereich und klicken dann auf die Design-Registerkarte des Inhalts-Bereichs. (Mehr über die Frame-Komponenten und ihre Funktion erfahren Sie in Lektion 6.)
Durch die Auswahl der Registerkarte Design wird der Visual Designer aufgerufen, der den Inhalts-Bereich zum Designer der Benutzeroberfläche macht, den Struktur-Bereich zum Komponenten-Baum, und der das Inspektor-Fenster anzeigt. Diese Elemente, die Sie in Abbildung 5.71 sehen, helfen Ihnen, die Benutzeroberfläche Ihres Programms zu entwickeln.
Abbildung 5.71: Der Visual Designer
Darüber hinaus enthält die Komponentenpalette im Hauptfenster die Drag&Drop-Komponenten, die Sie einsetzen können, um Ihr Programm visuell zu entwerfen. Nachdem Sie Menü-Komponenten im Frame angelegt haben, wird auch der Menü-Designer sichtbar, mit dem Sie das Menüsystem Ihres Programms entwickeln können, und zwar Haupt- und Kontextmenüs. Der Editor und der Visual Designer werden synchronisiert, so daß alle Änderungen, die Sie im Visual Designer vornehmen, auch in Ihrem Quellcode reflektiert werden.
Hier können Sie die Benutzeroberfläche für Ihre Anwendung entwerfen. Die Frame-Komponente agiert als Container der darin plazierten Komponenten. Das Projekt kann mehrere Frames haben, die die Fenster, Dialoge und andere Oberflächen Ihrer Anwendung darstellen.
In der Programmierumgebung von JBuilder basiert die visuelle Benutzeroberfläche für Ihr Java-Programm auf dem Inhalt des Frames. Hier haben Sie die Möglichkeit, die Eigenschaften des Frames grafisch zu ändern und die Kind-Komponenten zu plazieren und zu ändern. Das Kontextmenü stellt viele der Befehle bereit, die Sie zur Anordnung und Manipulation der Elemente im Frame brauchen.
Wenn der Inhalts-Bereich zum Designer der Benutzeroberfläche wird, zeigt der Struktur-Bereich eine Strukturhierarchie der Komponenten im aktuellen Frame an. Dabei handelt es sich um den Komponentenbaum, der alle visuellen Komponenten reflektiert, die der Benutzeroberfläche hinzugefügt werden. Sie können dem Projekt auch nicht-visuelle Komponenten hinzufügen, indem Sie sie auf diesem Feld ablegen.
Eine Komponente ist visuell, wenn sie im Designer als Grafik betrachtet werden kann, etwa eine
Schaltfläche oder eine Beschriftung. Eine Komponente ist nicht-visuell, wenn sie keine grafische Darstellung im Designer besitzt, wie
etwa ein Dialog oder eine Datenzugriffskomponente.
Bei dem Inspektor handelt es sich um ein separates Fenster, das aufgerufen wird, wenn die Design-Registerkarte selektiert wird. In diesem Fenster werden die Ereignishandler und die Komponenteneigenschaften zur Designzeit gesetzt. Wenn eine Komponente im Komponentenbaum oder im Designer selektiert wird, werden ihre Eigenschaften und Ereignishandler im Inspektor angezeigt. Wenn die Komponente im Inspektor selektiert wird, wird sie im Designer und im Komponentenbaum ebenfalls zur selektierten Komponente.
Das Inspektor-Fenster enthält zwei mehrspaltige Seiten, die Eigenschaften-Seite und die Ereignisse-Seite. Die Komponenteneigenschaften, die im Designer grafisch angezeigt werden, wie etwa Größe, Farbe und Position, werden auf der Eigenschaften-Seite aufgelistet und können hier verändert werden. Die Ereignisse-Seite werden die Ereignis-Handler erzeugt, die Methoden, die auf Nachrichten reagieren.
Ein Doppelklick auf einen der Einträge der Ereignisse-Seite für die Komponente fügt das Gerüst einer Methode in den Quellcode ein, das Ihre Anweisungen aufnimmt.
Nachdem das Gerüst für die Methode eingefügt ist, müssen Sie ihm Code hinzufügen, der Ihrem Programm mitteilt, wie Sie das Ereignis verarbeiten können.
Auf der Eigenschaften-Seite (Abbildung 5.72) listet die Spalte links alphabetisch die Eigenschaften auf, die Spalte rechts die Eigenschaftswerte. Klicken Sie auf die Eigenschaft, die Sie ändern wollen, oder verwenden Sie die inkrementelle Suche, indem Sie den Namen der gewünschten Eigenschaft eingeben. Klicken Sie in der rechen Spalte auf den Wert, den Sie ändern wollen. Wenn mehrere Objekte selektiert sind, werden alle Änderungen, die Sie für eine Eigenschaft vornehmen, für alle selektierten Objekte geändert.
Abbildung 5.72: Die Eigenschaften-Seite des Inspektors
Auf der Ereignisse-Seite (Abbildung 5.73) werden in der linken Spalte alphabetisch die Ereignisse aufgelistet, in der rechten Spalte die Ereignis-Handler. Klicken Sie auf das gewünschte Ereignis oder verwenden Sie die inkrementelle Suche, indem Sie den Namen des betreffenden Ereignisses eingeben. Wenn Sie in der rechten Spalten auf einen leeren Eintrag doppelklicken, wird ein Ereignis-Handler-Link angelegt und ein Gerüst für den Prozedurcode in den Quellcode im Editor eingefügt. Der Cursor wird am Ende der ersten Zeile der neu erzeugten Methode positioniert.
Abbildung 5.73: Die Ereignisse-Seite des Inspektors
Nachdem ein Ereignis-Handler erzeugt ist, kann er einem anderen Ereignis zugeordnet erden. Dazu klicken Sie auf den Dropdown-Pfeil rechts neben der Spalte und selektieren es aus der Liste der kompatiblen Handler (das sind diejenigen mit einer übereinstimmenden Parameterliste).
Der Menü-Designer wird aufgerufen, indem Sie auf ein Menü oder ein Popup-Menü im Komponentenmodus doppelklicken, während sich der AppBrowser im Design-Modus befindet. Sie können auch auf eine Menü-Komponente doppelklikken und im Popup-Menü Designer aktivieren auswählen. Dieser Objektedtior ermöglicht Ihnen, Ihre Menüs grafisch zu bearbeiten. Wenn Sie Menüelemente hinzufügen oder entfernen, zeigt der Menü-Designer das Menü so an, wie es später in Ihrer Anwendung aussehen wird.
Ein Menüleistenelement ist ein Menü-Element, das beim Aufruf ein Dropdown-Menü anzeigt. Ein Menübefehl ist ein Element, das beim Aufruf einen Befehl ausführt oder einen Dialog anzeigt. 
Abbildung 5.74: Der Menü-Designer
Der Menü-Designer ermöglicht Ihnen, sich sofort vorzustellen, wie das Menü, das Sie gerade anlegen, zur Laufzeit aussehen wird. Die Möglichkeit, Menüelemente herunterzuklappen und ganze Untermenüs anzuzeigen, um die Darstellung zu ändern, macht das Anlegen von Menüs zur einfachsten Aufgabe bei der Entwicklung Ihres Projekts.
Heute haben Sie einen Schnelldurchgang durch die IDE von JBuilder vorgenommen und seine kontextabhängige Hilfe, das Hauptfenster sowie den AppBrowser kennengelernt. Sie haben den Visual Designer gesehen, mit dem Designer für die Benutzeroberfläche sowie dem Komponentenbaum im AppBrowser, den Komponenteninspektor und den Menü-Designer.
F Steht der JBuilder von Borland auch für andere Plattformen als Windows zur Verfügung?
A Zum Zeitpunkt der Drucklegung dieses Buches wird der JBuilder nur unter Windows 95 und Windows NT unterstützt. Möglicherweise werden in Zukunft auch andere Plattformen unterstützt, aber noch ist nicht bekannt, welche Plattformen das sein werden. Die neuesten Informationen finden Sie auf der Web-Seite von Borland für die JBuilder-Unterstützung, http://www.borland.com/jbuilder/.
F Ich verwende gerne den Explorer, um Dateien zu suchen, und ich möchte die Ordner-Registerkarte entfernen, um Platz für die anderen Registerkarten zu schaffen. Wie kann ich das realisieren?
A Um eine Modus-Registerkarte aus dem AppBrowser zu entfernen, klicken Sie mit der rechten Maustaste auf diese Registerkarte und wählen aus dem Popup-Menü den Befehl Register Name entfernen.
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.
