Hinweis: JBuilder 3.5 Foundation kann für Linux und Windows kostenlos heruntergeladen werden!
Das AIFB setzt im Sommersemester 1999 erstmals den JBuilder als Entwicklungsumgebung für die Übungen zur Vorlesung "Kommerzielles Programmieren in Java" ein.
Diese kurze Einführung soll den Umstieg von den textorientierten Kommandozeilenprogrammen "javac" und "java", wie sie bisher verwendet wurden, auf die grafische Oberfläche des JBuilder erleichtern. Neben den Grundfunktionen zur Eingabe und zum Starten eines Programms werden wir auch schon die ersten Hilfsmittel kennenlernen, die der JBuilder beim Programmieren anbietet, und eine erste Projektdatei erzeugen, mit der wir mehrere Quelltexte bequem verwalten können. Zum Schluß folgt ein kurzes Beispiel, wie man ein Java-Programm mit einer grafischen Oberfläche versieht. In dieser Einführung wird der "JBuilder 2.01 Standard" verwendet.
Zum Ausdrucken steht diese Einführung in den Formaten Postscript und PDF zur Verfügung.
Wer noch eine generelle Einführung in Java braucht, sollte sich das Skript zur Vorlesung "Programmieren 1 - Java" ansehen. Auch hiervon gibt es eine druckbare Postscript-Fassung.
Je nach Installation befindet sich das JBuilder-Icon auf dem Desktop, dann kann der JBuilder einfach durch Doppelklick auf dieses Icon gestartet werden. Ansonsten sollte sich im "Programme"-Menü des Windows-Start-Menüs (der Knopf links unten auf dem Bildschirm) ein Eintrag für den "Borland JBuilder 2" finden. In diesem Menü startet man dann das Programm "JBuilder" oder "jbuilder.exe".
Nach dem Start nimmt die JBuilder-Menüleiste den oberen Teil des Bildschirm in seiner gesamten Breite ein. Vor allem die Menüs "Datei", "Projekt" und "Start" werden für uns von Interesse sein.
Wenn beim letzten Beenden der Entwicklungsumgebung ein Projekt geöffnet war, wird dieses in einem Fenster unterhalb der Menüleiste geöffnet. Wird der JBuilder zum allerersten Mal gestartet, erscheint das "Willkommen"-Projekt, das man sich durchaus einmal ansehen sollte. In den folgenden Abschnitten verwenden wir kein bestehendes Projekt, daher schließen wir die Projektdatei (nur diese, nicht den JBuilder an sich; s. rechts).
Dieser Schritt ist ziemlich wichtig, da das Standard-Projekt des JBuilders für uns unpassende Pfadeinstellungen enthält - alle unsere Dateien müssen aber auf dem Laufwerk "U:" (!) gespeichert werden.
Wir werden nun ein ganz normales, textbasiertes Java-Programm schreiben, das wir schon aus "Programmieren 1 - Java" (und vermutlich von vielen anderen Programmiersprachen her) kennen: "Hallo Welt". Es soll nichts anderes machen, als eben diesen Text auf dem Bildschirm auszugeben. Dazu wählen wir im Menü "Datei" den Menüpunkt "Öffnen/Erstellen..." und geben als Dateinamen "HalloWelt.java" ein (beim Feld "Suchen in:" sollte "User (U:)" stehen). Wenn wir nun die Schaltfläche "Öffnen" anwählen, erscheint ein dreigeteiltes Fenster. Links oben sehen wir alle geöffneten Dateien - derzeit nur unser "HalloWelt.java". Links unten befindet sich der Objekt-Browser, der Klassen, deren Abhängigkeiten, Attribute und Methoden anzeigt. Da wir noch keine Klasse programmiert haben, ist dieser Teil des Fensters erst einmal leer. Den größten Teil des Fensters nimmt rechts der Editor ein. In diesen geben wir nun das folgende Programm ein:
Zum Seitenanfang
public class HalloWelt {
public static void main(String[] args) {
System/* hier fehlt noch etwas! */
/* wir warten auf einen Tastendruck, damit das *
* DOS-Fenster nicht sofort wieder verschwindet */
try
{
System.in.read();
}
catch (Exception e) {}
}
}
Während der Eingabe aktualisiert der JBuilder den Objekt-Browser. Nach und nach erscheint dort also unsere Klasse HalloWelt und deren Methode main. Ebenso sehen wir, daß unsere neue Klasse von der Klasse Object erbt, obwohl wir keine Oberklasse mit extends angegeben haben. Object ist die Oberklasse aller Java-Klassen, so daß sie bei fehlendem extends implizit angenommen wird.
Nun wollen wir uns ansehen, welche Hilfen der JBuilder beim Programmieren bietet. Dazu löschen wir zunächst den Kommentar hinter System in unserem Quelltext, schreiben direkt hinter System einen Punkt und warten einen kleinen Moment. Der JBuilder erkennt, daß es sich bei System. offenbar um eine Klasse handelt und öffnet eine Liste, in der uns sämtliche Klassenmethoden und Klassenvariablen der Klasse System angeboten werden.
Wir können diese Information nun einfach nutzen und den gewünschten Methoden- oder Variablennamen eintippen, oder wir wählen den Namen in der Liste mit den Pfeiltasten aus.
Wir verwenden die Klassenvariable out (JBuilder bezeichnet Instanz- und Klassenvariablen als "Member", andere gebräuchliche Namen dafür sind "Felder" oder "Attribute"; wir werden letzteren benutzen). Nach Betätigen der Eingabetaste steht in unserem Programm nun System.out. Geben wir nun wieder einen Punkt ein, merkt der JBuilder, daß out ein Objekt ist und bietet uns entsprechend eine Liste aller Methoden und Variablen an. Zum Ausgeben von "Hallo Welt" wählen wir die Methode println.
Damit haben wir das übliche System.out.println zusammengesetzt, aber der JBuilder kann noch mehr.
Oftmals weiß man nicht genau, welche Parameter eine Methode erwartet. Und obwohl wir wissen, daß println einen String akzeptiert, geben wir zunächst nur die öffnende runde Klammer ein, und der JBuilder wird uns eine Liste aller zulässigen Parameter anbieten. Wer sich bisher noch nicht allzu viele Gedanken über diese Methode gemacht hat, wird erstaunt sein, wieviele verschiedene Datentypen von println akzeptiert werden.
Nebenbei ist dies ein Beispiel für das Überladen von Methoden. In der Klasse PrintStream (out ist ein Objekt dieser Klasse) gibt es für jeden hier aufgeführten Datentyp eine eigene Methode println. Wer sich dies einmal in den Original-Java-Quelltexten ansehen möchte, klickt mit der rechten Maustaste auf println und wählt im erscheinenden Popup-Menü den Eintrag "Symbol an Cursorposition anzeigen" aus. Der JBuilder öffnet daraufhin den Quelltext "PrintStream.java" und springt zu einer der println-Methoden. Wenn wir links unten im Objekt-Browser auf das Plus-Zeichen vor println klicken, klappt die nächste Hierarchieebene des Browsers auf, und wir können die diversen println-Methoden direkt per Mausklick anspringen.
Haben wir genug im Quelltext gestöbert (was natürlich auch bei System und out funktioniert), wählen wir links oben über der Dateiliste den Rückwärts-Pfeil an und landen wieder in unserem eigenen Quelltext.
Für unser Programm werden wir schließlich ganz einfach den String-Parameter verwenden, also vervollständingen wir die Zeile zu
System.out.println("Hallo Welt!");
Unser erstes Programm ist somit fertig. Wir sichern es mit dem Menüpunkt "Speichern" im Menü "Datei". Im Menü "Start" können wir das Programm mit dem Menüpunkt "Start 'HalloWelt'" übersetzen und ausführen lassen. Wenn beim Übersetzen kein Fehler aufgetreten ist, öffnet sich ein DOS-Fenster, in dem unser Text "Hallo Welt!" ausgegeben wird. Wir werden weiter unten sehen, wie wir Programme mit einer grafischen Oberfläche schreiben, die wie ein normales Windows-Programm zu bedienen sind.
Fehler beim Übersetzen werden übrigens recht übersichtlich gemeldet. Wenn wir beispielsweise statt println aus Versehen nur printn geschrieben hätten, wäre unterhalb des Editors ein weiteres Unterfenster mit einer Liste aller Fehler aufgegangen. Durch Doppelklick auf eine Fehlermeldung markiert der JBuilder dann automatisch die fehlerhafte Zeile im Quelltext.
In diesem Abschnitt gehen wir davon aus, daß die folgenden beiden Klassen als "Hallo2.java" und "Ausgabe2.java" als fertige Quelltexte auf der Festplatte im gleichen Verzeichnis gespeichert sind:
public class Hallo2 {
public static void main(String[] args) {
new Ausgabe2();
try
{
System.in.read();
}
catch (Exception e) {}
}
}
public class Ausgabe2 {
public Ausgabe2() {
System.out.println("Hallo Welt (Teil 2)");
}
}
Die main-Methode der Klasse Hallo2 instantiiert also ein Objekt der Klasse Ausgabe2, und im Konstruktor dieses Objektes wird eine Zeichenkette auf den Bildschirm geschrieben. Da das gerade erzeugte Objekt ansonsten nichts weiter macht, endet das Programm sofort wieder.
Bei diesen beiden Klassen könnte es sich um Quelltexte aus einer früheren Java-Vorlesung handeln, wir wollen sie nun im JBuilder übersetzen und ausführen. Dazu öffnen wir erst einmal beide Dateien nacheinander im JBuilder. Sollte im Dialog "Datei öffnen/erstellen" im passenden Verzeichnis keine Java-Quelltextdatei auftauchen, muß der Dateityp unten im Dialog auf "Java-Quellen (*.java)" umgestellt werden.
Wenn "Hallo2.java" nicht im Editor angezeigt wird, schalten wir links in der "Geöffnet-Liste" auf diesen Quelltext um. Nun können wir im "Start"-Menü den Punkt "Start 'Hallo2'" anwählen. Beide Quelltexte werden übersetzt, und das Programm wird korrekt ausgeführt. Das war es dann auch schon!
Der JBuilder beachtet übrigens, ob die gerade im Editor bearbeitete Klasse eine main-Methode enthält. Ist dies nicht der Fall, kann der "Start"-Menüpunkt auch nicht angewählt werden.
Wenn ein Programm aus mehreren Quelltexten besteht, werden die Dateien im JBuilder normalerweise nicht einzeln bearbeitet, wie wir es im vorangegangenen Abschnitt gesehen haben. Stattdessen werden alle Dateien, die zu einem Programm gehören, zu einem Projekt zusammengefaßt. Dazu gehören nicht nur die Java-Quelltexte, sondern auch die Dokumentation. Alle Einstellungen eines Projektes werden in einer speziellen Projektdatei gespeichert. In diesem Abschnitt werden wir die beiden Quelltexte des vorangegangenen Abschnitts zu einem Projekt zusammenfassen.
Dazu wählen wir im Menü "Datei" den Punkt "Neues Projekt..." an. Als Dateiname verwenden wir "Hallo.jpr", den Rest des Dialogs füllen wir passend auf (s. Bild). Nun klicken wir auf die Schaltfläche "Fertigstellen".
Es öffnet sich das altbekannte dreigeteilte Fenster, aber statt der "Geöffnet-Liste" finden wir links oben jetzt den Projekt-Browser vor. Darin sehen wir mit "Hallo.html" unsere Dokumentationsdatei, die auch rechts dargestellt wird. Wenn wir die Dokumentation verändern wollen, müssen wir unterhalb des Editors vom Karteireiter "Ansicht" auf den Karteireiter "Quelltext" umschalten. Grundlegende Kenntnisse in HTML könnten dann allerdings nicht schaden ... Wir wollen uns aber um die Java-Quelltexte kümmern, die unserem Projekt noch fehlen.
Oberhalb des Projekt-Browsers befindet sich links oben im Fenster ein kleines Plus-Symbol. Wenn wir dies anklicken, können wir unserem Projekt eine Java-Quelltextdatei hinzufügen, was wir nacheinander mit "Hallo2.java" und "Ausgabe2.java" machen wollen. Danach speichern wir unser Projekt mit dem Menüpunkt "Projekt speichern" im Menü "Datei" ab. Wichtig: In der Projektdatei merkt sich der JBuilder nur, welche Dateien zum Projekt gehören, nicht aber die Dateien selbst (d.h. deren Inhalt). Würden wir also die beiden Quelltexte "Hallo2.java" und "Ausgabe2.java" von der Festplatte löschen, hätten wir auch in unserem Projekt keinen Zugriff mehr darauf.
Da wir unsere Quelltexte zu einem Projekt zusammengefaßt haben, können wir nun einen beliebigen Java-Quelltext unseres Projektes im Editor bearbeiten - im "Start"-Menü wird uns unter dem entsprechenden Menüpunkt trotzdem immer die Klasse zum Ausführen angeboten, welche die main-Methode enthält. Keine Regel ohne Ausnahme: Wenn wir gerade die HTML-Dokumentation bearbeiten, würde der JBuilder versuchen, ein innerhalb dieser HTML-Datei referenziertes Java-Applet zu starten. Aber da wir Applets noch nicht kennen, starten wir unser Projekt einfach nicht aus der HTML-Datei heraus.
Projekte werden insbesondere bei der visuellen Entwicklung von Applikationen interessant, für die der JBuilder vor allem entwickelt wurde. Wie wir grafische Oberflächen mit ein paar Mausklicks entwerfen können, sehen wir im übernächsten Abschnitt.
Applets sind vom Namen her "kleine Applikationen" - was dürfen wir darunter verstehen? Im Gegensatz zu Java-Applikationen sind Applets dazu gedacht, in HTML-Code eingebettet zu werden, sie werden also von einem Java-fähigen HTML-Browser angezeigt. Alternativ gibt es dafür spezielle AppletViewer, die in ein HTML-Dokument eingebettete Applets anzeigen können. Da Applets in einem Web-Browser angezeigt werden, unterliegen sie gewissen Einschränkungen, um die Sicherheit eines Systems nicht zu gefährden. Schließlich können Applets über das Netz von einem fremden Rechner geladen werden, und man möchte ja nicht, daß bösartige Applets die eigene Festplatte löschen. Diese restriktive Handhabung von Applets nennt man auch "Sandkasten-Prinzip". Applets können in ihrem Sandkasten so viel spielen wie sie wollen, aber sie kommen aus ihm nicht heraus und können somit nichts kaputt machen.
Wir legen nun unsere Sandschaufel beiseite und öffnen mit dem Menüpunkt "Neu..." im "Datei"-Menü einen Dialog (s. rechts), mit dem wir ein neues Applet erzeugen können. Zunächst werden wir vom JBuilder aufgefordert, ein neues Projekt anzulegen. Wir tun dies und nennen die Datei "HalloWeltApplet.jpr" (das Projekt sollte in einem eigenen Verzeichnis liegen, beim Feld "Datei" sollte also exakt "U:\HalloWeltApplet\HalloWeltApplet.jpr" stehen!). Dann erscheint der "Applet-Experte", der uns in drei Schritten bei der Erzeugung des Applet-Grundgerüsts behilflich ist. Wir brauchen im Moment davon allerdings nur den ersten Schritt (wer neugierig ist, kann sich mit der Schaltfläche "Weiter" die anderen Schritte ansehen; mit "Zurück" gelangt man dann wieder zu Schritt 1).
Das Feld "Package" sollte vom JBuilder auf "HalloWeltApplet" gesetzt worden sein. Bei "Klasse" tragen wir "HalloApplet" ein. (Ein kleiner Hinweis: Im Feld "Datei" sollte nirgends ein Leerzeichen angezeigt werden, da der AppletViewer, den wir verwenden werden, sonst mit dem Dateinamen nicht zurecht kommt. Aber wenn wir die Voreinstellungen des JBuilders nicht verändert haben, sollte alles korrekt gesetzt sein.)
Wenn wir nun die Schaltfläche "Fertigstellen" anwählen, erzeugt der JBuilder neben den beiden schon bekannten Dateien (Projektdatei, HTML-Dokumentationsdatei) zwei weitere: Das Applet "HalloApplet.java" und die HTML-Datei "HalloApplet.html", in der das Applet augerufen wird. "HelloApplet.java" enthält den Quelltext für eine von der Swing-Klasse JApplet abgeleitete eigene Applet-Klasse. Den Quelltext müssen wir derzeit noch nicht verstehen, und den für uns relevanten Teil werden wir später noch hinzufügen. Swing ist eine sehr aktuelle Java-Klassenbibliothek zur Programmierung grafischer Benutzeroberflächen, und weil Swing so neu ist, kann unser Applet von den meisten HTML-Browsern noch gar nicht angezeigt werden - sie kennen Swing einfach noch nicht. Der JBuilder bringt aber den AppletViewer mit, der auch solche modernen Applets anzeigen kann.
Wenn wir das Applet aufrufen wollen, geschieht das natürlich wieder über das "Start"-Menü. Diesmal steht dort allerdings "Start Applet in 'HalloApplet.html'". In dieser HTML-Datei wird also festgelegt, wie unser Applet aufgerufen werden soll (z.B. mit welcher Größe). Wer Applets auf seiner Homepage integrieren möchte, kann unterhalb des Editors auf den Karteireiter "Quelltext" umschalten - interessant ist dabei der Bereich zwischen "<APPLET" und der darauffolgenden schließenden Klammer. Starten wir unser Applet nun, wird ein Fenster mit grauem Hintergrund geöffnet - mehr nicht. Das ist eigentlich auch klar, denn wir haben soeben das minimale Standard-Applet des JBuilders gestartet, und bisher haben wir das Applet noch nicht passend erweitert. Also schließen wir das Applet erst einmal wieder mit dem Menüpunkt "Quit" im "Applet"-Menü.
Nun wollen wir unser Applet so erweitern, daß es eine Zeichenkette ausgibt. Das geschieht bei Applets am besten in der geerbten Methode paint, so daß wir diese Methode nun überschreiben müssen, um sie an unsere Zwecke anpassen zu können. Wenn im Editor die Datei "HalloApplet.java" angezeigt wird, können wir im Menü "Experten" den Punkt "Methoden überschreiben" auswählen.
Im Dialog "Geerbte Methoden überschreiben" wählen wir in der Klasse java.awt.Container die Methode paint(Graphics) aus. Nachdem wir auf die Schaltfläche "OK" geklickt haben, wird der entsprechende Quelltext an das Ende von "HalloApplet.java" angefügt. Links im Objekt-Browser erscheint unsere neu hinzugefügte Methode ebenfalls, ein Klick darauf bringt uns zur passenden Stelle im Quelltext.
Der JBuilder hat paint mit einer Methode überschrieben, die nichts weiter macht, als die geerbte Methode der Oberklasse aufzurufen. Im Moment hat das Überschreiben von paint also noch keine sichtbaren Auswirkungen, aber genau dafür erweitern wir die Methode nun wie folgt:
public void paint(Graphics g) {
super.paint(g);
Dimension d = getSize();
g.drawString("Hallo Applet-Welt!",d.width/4,d.height/2);
}
Im Quelltext haben wir den vom JBuilder automatisch erzeugten Parameter parm1 durch g ersetzt, aber das ist natürlich Geschmackssache. Interessanter ist, was in der paint-Methode passiert: Zunächst rufen wir die paint-Methode der Oberklasse auf - das ist bei überschriebenen Methoden meistens eine gute Idee. In unserem Fall sorgt dies allerdings "nur" dafür, daß der Hintergrund des Applets grau gezeichnet wird. Danach ermitteln wir die Größe des Applets in Bildschirmpunkten (Pixel). Die Methode getSize ist erst ab Java 1.1 vorhanden, ältere Browser können das Applet also vermutlich nicht ausführen. Da uns der JBuilder aber ein modernes Swing-Applet erzeugt hat, wollen wir auch die aktuellste Methode zur Größenberechnung einsetzen. Zum Schluß wird dann die übliche Zeichenkette ausgegeben - diesmal allerdings nicht einfach in der DOS-Konsole, sondern als grafischer Text innerhalb des Applet-Bereichs! drawString ist dabei eine Methode der Klasse Graphics, die als ersten Parameter die Zeichenkette, im zweiten Parameter die X- und im dritten Parameter die Y-Position der Zeichenkette erwartet. Unser Text beginnt also bei einem Viertel der Breite und der halben Höhe des Applets.
Nun können wir unser Applet erneut mit Hilfe des "Start"-Menüs aufrufen, und diesmal sehen wir nicht nur ein graues Fenster. Für eine "richtige" Applikation fehlen jetzt eigentlich nur noch Schaltflächen, die der Anwender anwählen kann.
Bei einer eigenständigen Java-Applikation könnten wir ähnlich wie beim Applet vorgehen, d.h. eine passende paint-Methode überschreiben und unsere Zeichenkette darin ausgeben. Wir wollen nun aber eine grafische Oberfläche (GUI, "Graphical User Interface") entwerfen, um eine - wenn auch geringe - Interaktion mit dem Benutzer zu ermöglichen.
Mit dem Menüpunkt "Neu..." im Menü "Datei" erzeugen wir dieses Mal eine Anwendung. Wir werden wie üblich zunächst aufgefordert, ein neues Projekt anzulegen, das wir "HalloFensterWelt" (Dateiname und Verzeichnis) nennen. Danach erscheint dann der "Anwendungs-Experte", der mit zwei Schritten eine komplette Java-Anwendung erzeugen kann. In Schritt 1 sollte der Package-Name "HalloFensterWelt" lauten, den Klassennamen setzen wir auf "HalloAnwendung". Mit der Schaltfläche "Weiter" gelangen wir nach Schritt 2. Dort nennen wir die Frame-Klasse "HalloFrame", suchen uns einen schönen Fenstertitel aus und schalten bei den Optionen nur "Frame auf Bildschirm zentrieren" ein. Nun wählen wir "Fertigstellen" an, und der Experte wird aktiv.
Es werden zwei Java-Quelltexte erzeugt. "HalloAnwendung.java" ist die Steuerklasse (enthält also die main-Methode), die ein Fenster einrichtet und öffnet. Interessanter ist für uns "HalloFrame.java". Dies ist unsere von der Swing-Klasse JFrame abgeleitete Fenster-Klasse. Wir lassen also "HalloFrame.java" im Editor anzeigen, aber anstatt den Quelltext zu bearbeiten, schalten wir unterhalb des Editors auf "Design" um. Das Editor-Fenster wird nun nochmals geteilt. Im linken Teil sehen wir die grafische Darstellung unseres späteren Fensters, rechts werden die Eigenschaften des gerade markierten Elements angezeigt. Im Moment sind dies die Eigenschaften des JFrame-Objekts selbst, da wir noch keine weiteren Elemente hinzugefügt haben.
Ganz oben unterhalb der Menüleiste schalten wir auf den Karteireiter "Swing" um und klicken auf das kleine Bild der "OK"-Schaltfläche. Dann bewegen wir den Mauspfeil wieder über die Darstellung unseres Fensters, und zwar solange, bis ganz unten rechts im Projekt-Fenster "this (BorderLayout): South" angezeigt wird. An diese Stelle des Fensters klicken wir einmal, woraufhin der JBuilder ganz unten in unser Fenster eine Schaltfläche mit Namen "jButton1" einfügt.
Die Eigenschaften rechts passen ihre Einstellungsmöglichkeiten immer an das markierte Dialogelement an. Wenn wir also auf den Fensterhintergrund klicken, sehen wir andere Optionen, als wenn wir die soeben erzeugte Schaltfläche markieren.
Links unten im Projektfenster ist nun nicht mehr der Objekt-Browser, sondern der GUI-Browser zu sehen. Hier werden also alle verwendeten Dialogelemente hierarchisch dargestellt. Das markierte Dialogelement wird dabei unterlegt angezeigt. this bezeichnet unsere von JFrame abgeleitete Klasse.
Wir wollen nun davon ausgehen, daß jButton1 markiert ist. Bei den Eigenschaften tragen wir im Feld "text", wo derzeit "jButton1" steht, die Zeichenkette "OK" ein und bestätigen die Aktion mit der Eingabetaste. Der Text unserer Schaltfläche ändert sich sofort entsprechend! Der Unterschied zwischen Text und Name der Schaltfläche ist übrigens recht wichtig: Während der Text die sichtbare Zeichenkette angibt, ist der Name der Variablenname, der im Quelltext für unsere Schaltfläche verwendet wird. Im Feld "toolTipText" können wir noch einen kurzen Hilfstext eingeben, hier beispielsweise "Beendet das Programm".
Nun markieren wir in der Menüleiste die JLabel-Schaltfläche (das umrandete "A") und klicken anschließend in die Mitte unseres Fensters (unten rechts sollte dabei "this (BorderLayout): Center" angezeigt werden). Es erscheint der vertikal zentrierter Text "jLabel1". Bei den Eigenschaften setzen wir das Feld "horizontalAlignment" auf Null, dann ist der Text auch horizontal zentriert. Direkt über dem Feld wählen wir "foreground" an. Wenn wir nun rechts neben "Black" die drei Punkte anklicken, können wir im erscheinenden Dialog unter "Standardfarben" die Farbe "Red" auswählen, und schon wird unser Text rot angezeigt. In das Feld "text" schreiben wir "Hallo Fenster-Welt!", bei "toolTipText" tragen wir auch irgend etwas mehr oder weniger sinnvolles ein.
Eigentlich sind wir jetzt fertig und können unsere erste eigenständige Java-Applikation über das "Start"-Menü aufrufen. Nach ein paar Sekunden öffnet sich unser gewünschtes Fenster. Wenn wir den Mauspfeil kurze Zeit über dem Text oder der Schaltfläche stehen lassen, wird der Text, den wir bei "toolTipText" eingetragen haben, angezeigt. Und wenn wir auf "OK" klicken - passiert gar nichts. Ein Fehler? Nein, denn wir haben ja noch gar nicht festgelegt, was passieren soll, wenn der Benutzer die Schaltfläche anwählt. Also beenden wir unser Programm durch das Schließfeld oben rechts im Fenstertitel (das "X").
Sobald wir wieder im JBuilder sind, führen wir auf die Darstellung der "OK"-Schaltfläche einen Doppelklick aus. Es wird vom Design- in den Quelltextmodus umgeschaltet, und wir landen in der Methode, die für die Aktion nach Anklicken der Schaltfläche zuständig ist. In die leere Zeile fügen wir einen Befehl zum Beenden unseres Programms ein, so daß die Methode dann wie folgt aussieht:
void jButton1_actionPerformed(ActionEvent e) {
System.exit(0);
}
Unmittelbar darüber verwendet der JBuilder diesen Befehl übrigens dazu, um das Programm beim Anklicken des Fenster-Schließfeldes zu beenden - deshalb hatte dies auch beim ersten Start schon funktioniert. Wenn wir unser Programm nun starten, können wir es auch durch Anklicken von "OK" wieder beenden.
So viel zum ersten Einblick in JBuilder2. Weitere Themen wie z.B. das Auswerten von Eingabemasken werden bei Gelegenheit ergänzt.
Allgemeine Links rund um Java gibt es hier.
Letzte Änderung 7.4.2000 - Thomas Much