Java-Entwicklung mit NetBeans 3.4 - Jürgen Bayer
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Jürgen Bayer Java-Entwicklung mit NetBeans 3.4
Inhaltsverzeichnis 1 Einführung 1 1.1 Installation 1 1.2 Der Benutzerordner 1 1.3 Starten von NetBeans 1 1.4 Integration der Java-Dokumentation 2 2 Hello World mit NetBeans 3 2.1 Erzeugung eines neuen Projekts 4 2.1.1 Projekte 4 2.1.2 Was Sie über verbundene Dateien wissen sollten 5 2.1.3 Erzeugen eines neuen Projekts 6 2.1.4 Verbinden des Projekt-Hauptordners 6 2.1.5 Verbinden des Haupt-Ordners mit dem Projekt 8 2.2 Anlegen einer Start-Klasse für das Projekt 9 2.3 Programmieren und Starten des Programms 15 2.3.1 Nützliche Features 15 2.3.2 Javadoc-Dokumentation 15 2.3.3 Das erste Programm 17 2.3.4 Kompilieren und Starten 17 2.4 Grundlagen zum Umgang mit NetBeans 18 2.4.1 Pakete 18 2.4.2 Integration von externen Projekten 19 2.5 Entwickeln einer Anwendung mit grafischer Oberfläche mit NetBeans 20 2.6 Erzeugen des Projekts und des Startformulars 21 2.7 Entwurf des Formulars 22 2.8 Einstellen der Eigenschaften 23 2.9 Programmieren 24 2.9.1 Methode zur Ereignisbehandlung erzeugen 24 2.9.2 Programmierung der Berechnung 25 2.9.3 Programmieren des Beenden-Schalters 26 2.10 Testen des Programms 26 2.11 Die vom Compiler erzeugten Dateien 27 3 Einfaches Debuggen 28
3.1 Grundlagen 28 3.1.1 Ausnahmen und logische Fehler 28 3.1.2 Haltepunkte 28 3.1.3 Ein Beispiel 29 3.2 Einfaches Debuggen 30 3.2.1 Überwachungsausdrücke 30 4 Tipps 32 4.1 Abkürzungen 32 5 Anhang 34 5.1 Wichtige NetBeans-Tastenkombinationen 34 5.2 Vordefinierte Abkürzungen 35 6 Index 38
NetBeans ist eine freie, sehr gute Entwicklungsumgebung für Java, die schon sehr viele Features
bietet und für die viele Erweiterungen verfügbar sind. NetBeans ist fast identisch mit Sun ONE
Studio 4 (ehemals Forte for Java), bietet aber (aus meiner Sicht) einige Vorteile wie z. B. eine
(subjektiv empfundene) etwas bessere Performance und eine hilfreiche Anzeige der Javadoc-
Dokumentation von aufgerufenen Methoden. Sie finden NetBeans auf der Seite
www.netbeans.org.
Die Installation von NetBeans ist einfach. Zuvor müssen Sie auf jeden Fall das aktuelle Java-
SDK installieren (zurzeit java.sun.com/j2se/1.4.1/download.html). Die weiteren
Systemvoraussetzungen sind auf der Seite
www.netbeans.org/devhome/docs/releases/34/README.html#SystemRequ
irements beschrieben.
Unter Windows starten Sie dann einfach die Datei NetBeansIDE-release34-win32.exe. Unter
Linux loggen Sie sich als root ein (da Sie ansonsten nicht über ausreichende Rechte verfügen)
und rufen die Datei NetBeansIDE-release34-linux.bin auf, die Sie zunächst ausführbar machen
müssen:
$ chmod +x NetBeansIDE-release34-linux.bin
$ ./NetBeansIDE-release34-linux.bin
Die Angabe der Version (hier 3.4) im Dateinamen kann natürlich auch eine andere
als die hier verwendete sein wenn Sie eine neuere Version von NetBeans
verwenden.
Das Installationsprogramm sucht zunächst nach einer installierten Java-Virtual-Machine. Fehlt
diese bzw. ist eine zu alte Version installiert, meldet das Programm diesen Umstand und wird
beendet. Ist alles in Ordnung folgen Sie einfach den Installationsanweisungen.
NetBeans (3.4) legt beim ersten Start für den in Windows oder Linux eingeloggten Benutzer in
dessen Benutzerordner einen Unterordner .netbeans\3.4 an, in dem verschiedene
Konfigurationsdaten, Beispiele und die Projekte des Benutzers gespeichert werden. Unter
Windows ist dies normalerweise der Ordner C:\Dokumente und
Einstellungen\Administrator\.netbeans\3.4, unter Linux der Ordner
\home\\.netbeans\3.4. Beachten Sie, dass Linux den Ordner .netbeans
normalerweise versteckt da dessen Name mit einem Punkt beginnt. Im Konqueror der KDE
werden aber auch solche Ordner angezeigt.
Falls Sie NetBeans noch nie gestartet haben, sollten Sie dies nun nachholen, damit die
Entwicklungsumgebung den Benutzerordner korrekt anlegt.
Unter Windows starten Sie NetBeans einfach über den entsprechenden Eintra im Start-Menü.
Unter Linux müssen Sie dazu die Datei runide.sh ausführen, die Sie im bin-Ordner des
NetBeans-Ordners finden (normalerweise /opt/NetBeans IDE 3.4/bin). Beim ersten Start
erhalten Sie die Möglichkeit, eventuell vorhandene Einstellungen einer älteren NetBeans-
Einführung 1Installation zu importieren. Bei einer neuen Installation überspringen Sie diesen Import. Danach
startet NetBeans (recht langsam ...).
!
NetBeans ermöglicht die Einbindung der Java-Dokumentation so, dass die
Entwicklungsumgebung automatisch die Beschreibung von Methoden anzeigt wenn Sie diese
im Quelltext schreiben und die Dokumentation der Klasse anzeigt wenn Sie auf einer
Eigenschaft oder Methode im Quelltext (ALT) + (F1) betätigen.
Wenn Sie die Java-Dokumentation, die Sie über die Seite
java.sun.com/j2se/1.4.1/download.html finden, noch nicht installiert haben,
entpacken Sie diese idealerweise in den Ordner javadoc in Ihrem NetBeans-Benutzerordner.
Die Integration der Java-Dokumentation erfolgt über Einstellungen im Javadoc Manager.
Voreingestellt ist eben der Ordner javadoc in Ihrem Benutzerordner (und zusätzlich eine Datei
xml-apis.zip, die im Unterordner docs des NetBeans-Ordners gespeichert ist). Sie können im
Javadoc Manager, den Sie über das Tools-Menü erreichen, zwar auch andere Ordner für Java-
Dokumentationen hinzufügen. Leider übernimmt der Manager diese Einstellungen nur für das
aktuelle Projekt, sodass Sie diese für jedes neue Projekt wiederholt ausführen müssen wenn Sie
die Java-Dokumentation in einem anderen Ordner als dem voreingestellten entpacken.
Leider besteht scheinbar keine einfache Möglichkeit, die Java-Dokumentation so zu integrieren,
dass ein Aufruf über das Hilfe-Menü möglich ist. Sie können das Menü aber auch erweitern (die
Vorgehensweise ist mir allerdings zurzeit noch unklar ...). Alternativ können Sie im Javadoc
Manager für den Eintrag der Java-Dokumentation die Einstellung Hidden auf False einstellen.
Dann zeigt der Explorer den Ordner der Java-Dokumentation an und Sie erhalten die
Möglichkeit, die Dokumentationsdateien direkt zu öffnen. Startpunkt der Dokumentation ist die
Datei index.html.
Einführung 2" # !
Damit Sie lernen, mit NetBeans umzugehen, entwerfen Sie nun das Hello-World-Programm mit
Hilfe dieser Entwicklungsumgebung.
NetBeans ist sehr komplex. Sie können bei der Entwicklung eines Java-Programms
mit NetBeans recht viele verschiedene Wege gehen und eine Vielzahl an Features
nutzen. Ich kann den Umgang mit dieser Entwicklungsumgebung im Rahmen
dieses Artikels nur ansatzweise beschreiben und zeige deshalb einen Weg zur
Erstellung eines Programms, den ich für den Anfang für möglichst einfach und
ideal halte. Leider ist dieser Weg trotzdem ein wenig komplizierter, als ich es gerne
hätte. Ich wollte aber nicht auf die grundsätzliche Beschreibung von NetBeans
verzichten, weil Sie mit dieser Entwicklungsumgebung sehr wichtige Hilfsmittel
beim Schreiben von Programmen und vor allen Dingen einen Debugger zum
Testen Ihrer Programme besitzen. Wenn Sie intensiver mit NetBeans
programmieren wollen, müssen Sie sich wohl noch ein wenig mehr mit den
Konzepten dieser Entwicklungsumgebung beschäftigen.
Die Tastenkombinationen, die ich in diesem Abschnitt beschreibe, finden Sie in
einer übersichtlichen Form auch im Anhang.
NetBeans benötigt scheinbar sehr viele Systemressourcen. Wenn Sie gleichzeitig
mit dieser Entwicklungsumgebung andere Programme geöffnet haben, kann es
schon einmal passieren, dass diese oder das gesamte System abstürzen (was bei mir
allerdings nur unter Windows, da aber leider sehr häufig der Fall war). Speichern
Sie also Ihre aktuelle Arbeit immer ab, wenn Sie mit NetBeans arbeiten. Die
Editoren von NetBeans sind zudem leicht »buggy« (fehlerbehaftet). Es kann schon
einmal passieren, dass der Quellcode- oder der Formulareditor nicht auf das
Klicken mit der Maus reagieren, sodass Sie nicht die Möglichkeit haben, Ihr
Programm weiter zu bearbeiten. In einigen Fällen hilft dann ein Schließen und
erneutes Öffnen der entsprechenden Datei. Häufig müssen Sie NetBeans aber auch
komplett neu starten.
Unter Linux funktionieren zudem einige der Tastenkombinationen, die ich in im
weiteren Verlauf beschreibe, nicht, wenn Sie NetBeans in der KDE starten. Das
liegt daran, dass die KDE einige Tastenkombinationen für sich in Anspruch nimmt.
Wenn Sie diese Tastenkombinationen ohne Probleme in NetBeans verwenden
wollen, müssen Sie deren Zuordnung in der KDE entfernen.
Hello World mit NetBeans 3$ %
Nachdem Sie NetBeans gestartet und den eventuellen Willkommensdialog geschlossen haben,
sieht die Entwicklungsumgebung in etwa aus wie in Abbildung 2.1.
Abbildung 2.1: NetBeans
$ %
In NetBeans arbeiten Sie wie in anderen Entwicklungsumgebungen mit einem Projekt. Ein
Projekt fasst (zumindest) alle Dateien zusammen, die zu einem Programm gehören. Wenn Sie
ein Projekt kompilieren, erzeugt NetBeans für alle im Projekt eingebundenen Dateien
kompilierte .class-Dateien. Wenn Sie ein kompiliertes Projekt ausführen, setzt NetBeans den
Java-Classpath so, dass alle zum Projekt gehörenden Klassen gefunden werden.
Dazu können Sie beliebig viele Dateiordner, Archivdateien (.zip, .jar, .war, .ear) oder Dateien
aus Versions-Kontrollsystemen mit dem Projekt verbinden (mounten). NetBeans bezeichnet
diese als »Filesystems« (Dateisysteme). Binden Sie Archivdateien ein, zeigt NetBeans
automatisch den Inhalt dieser Dateien an und kann damit umgehen, ohne dass Sie diese
entpacken müssen. Das Einbinden von Versions-Kontrollsystemen ermöglicht die Benutzung
der von diesen Systemen angebotenen Features (wie eben z. B. die Versionskontrolle, die es
ermöglicht, Zwischenversionen einer Datei zu archivieren um bei Bedarf später wieder darauf
zugreifen zu können).
Ein typisches Projekt besteht aus einem Dateiordner, der die Hauptdateien des Projekts
verwaltet. Meist sind dann noch weitere Dateiordner oder Archivdateien eingebunden, die
Bibliotheken speichern, die im Projekt verwendet werden. Zusätzlich werden oft auch Ordner
oder Archivdateien eingebunden, die Dokumentationen enthalten (z. B. die Java-
Dokumentation).
Hello World mit NetBeans 4Beim ersten Start hat die Entwicklungsumgebung bereits ein Projekt geöffnet, das als Default
bezeichnet wird. Dieses Projekt ist auch gleich ein Beweis dafür, dass NetBeans etwas anders
mit dem Begriff Projekt umgeht als andere Entwicklungsumgebungen (wie z. B. Delphi und
Kylix). Das Default-Projekt besteht nämlich per Voreinstellung aus einem Ordner sampledir,
der gleich mehrere Unterordner mit unterschiedlichen Programmen enthält. Sie können in einem
NetBeans-Projekt also beliebig viele Programme verwalten.
Wenn Sie allerdings nur ein Programm in einem Projekt verwalten, ermöglicht dies
projektspezifische Compiler-Einstellungen und erleichtert das Kompilieren und Starten des
Programms. Außerdem ist das Einbinden von externen (nicht zum Projekt gehörenden)
Bibliotheken nur über ein Einzelprogramm-Projekt möglich. Wenn Sie mehrere Programme in
einem Projekt verwalten, müssen Sie zum Kompilieren und Starten immer erst den Ordner
auswählen, in dem das Programm gespeichert ist, und Sie können keine externen Bibliotheken
einbinden.
# & & '
Alle Dateien, die zu einem Projekt gehören, müssen zumindest als Dateisystem mit dem Projekt
verbunden werden. Wenn Sie z. B. ein Projekt erstellen, das mit einer Bibliothek arbeitet,
müssen Sie den Ordner der Bibliothek als Dateisystem mounten. NetBeans setzt den Java-
Classpath beim Kompilieren automatisch nach den verbundenen Dateisystemen. Die Einstellung
in der Systemvariable CLASSPATH wird übrigens von NetBeans beim Kompilieren außer Kraft
gesetzt, sodass der Java-Compiler dort eingebundene Ordner nicht findet. Sie müssen also alle
Bibliotheksordner explizit in NetBeans einbinden.
Beim Mounten können Sie zwei Wege gehen:
• Sie mounten Dateiordner und Archivdateien so, dass diese nur im FILESYSTEMS-Register
des Explorers erscheinen und nicht dem Projekt direkt zugeordnet sind;
• Sie verbinden diese Dateien zusätzlich direkt mit dem Projekt, sodass diese auch im
PROJECT-Register erscheinen.
Wenn Sie neue Dateien erzeugen, können Sie diese über den Befehl ADD NEW im Kontextmenü
des PROJECT-Registers als Dateisystem mounten und gleichzeitig direkt dem Projekt zuordnen.
Über den entsprechenden Befehl im Kontextmenü des FILESYSTEMS-Registers oder im Menü
FILE | MOUNT FILESYSTEM erzeugen Sie neue Dateien, die nur über ein Dateisystem verbunden
sind. Wenn Sie bereits vorhandene Dateien mit dem Projekt verbinden wollen, müssen Sie
zunächst das Dateisystem mounten und die Dateien dann über den Befehl ADD EXISTING im
Kontextmenü des PROJECT-Registers mit dem Projekt verbinden.
Sie können Java-Dateien sehr einfach mounten indem Sie im Windows-Explorer
oder Linux-Konqueror auf die Datei doppelklicken. Ist die Dateiendung .java mit
NetBeans verknüpft (was per Default der Fall ist), wird das Dateiordner
automatisch als Dateisystem im aktuellen Projekt verbunden.
Laut Dokumentation werden beim Kompilieren eines Projekts nur die Dateien berücksichtigt,
die direkt dem Projekt zugeordnet sind. Als sich das überprüfte, wurden aber auch die Java-
Dateien kompiliert, die zwar nur über das FILESYSTEMS-Register eingebunden waren, deren
Klassen aber im Projekt verwendet wurden (was auch logisch ist, denn die eingebundenen
Dateisysteme werden beim Kompilieren in den Java-Classpath aufgenommen). Wenn Sie Java-
Dateien zusätzlich dem Projekt direkt zuordnen, werden diese aber auch dann kompiliert, wenn
Sie in den Haupt-Dateien des Projekts gar nicht verwendet werden. Die Startklasse eines
Projekts muss demnach auf jeden Fall auch dem Projekt direkt zugeordnet sein.
Hello World mit NetBeans 5$ %
Sie sollten für Ihre Java-Programme jeweils eigene Projekte anlegen, auch wenn diese zurzeit
noch recht einfach strukturiert sind. Wenn Sie sich an die Arbeit mit Projekten gewöhnen, haben
Sie weniger Probleme bei der Programmierung.
Erzeugen Sie für das erste mit NetBeans erstellte Programm also ein neues Projekt. Dazu
verwenden Sie den Projektmanager, den Sie über das PROJECT-Menü öffnen können. Legen Sie
über den NEW-Schalter ein neues Projekt an, das Sie vielleicht HelloWorld nennen. Über den
Projektmanager können Sie Ihre Projekte später wieder öffnen. NetBeans startet aber auch
immer mit dem zuletzt aktuellen Projekt, sodass Sie beim nächsten Start direkt an diesem
Projekt weiterarbeiten können.
NetBeans verwaltet die Einstellungen aller Projekte in einem Ordner, der so
benannt ist wie das jeweilige Projekt und der im Ordner system\projects im
Benutzerordner angelegt wird.
( & $ % " )
Zur Verwaltung der Haupt-Dateien eines Projekts sollten Sie einen spezifischen Ordner mit dem
Projekt verbinden (»mounten«). Dazu verwenden Sie das Menü FILE | MOUNT FILESYSTEM
oder den Befehl MOUNT im Kontextmenü des FILESYSTEMS-Registers. Klicken Sie dann auf
den Eintrag LOCAL DIRECTORY im erscheinenden NEW WIZARD-Dialog. Nachdem Sie den
NEXT-Schalter betätigt haben, können Sie den Ordner auswählen, in dem Sie die Dateien des
Projekts verwalten wollen.
Sie können über den New Wizard den für das Projekt benötigten Unterordner
anlegen, indem Sie auf das Ordnersymbol (das dritte von rechts) klicken. Klicken
Sie danach einmal auf den neuen Ordner und geben Sie den Namen ein.
Erstellen Sie also gegebenenfalls einen Ordner für Ihre Java-Projekte (z. B. C:\Projekte\Java
bzw. /Projekte/Java). In diesem Ordner erstellen Sie für Ihr erstes Projekt einen Unterordner
HelloWorld, den Sie dann mit dem Projekt verbinden.
Hello World mit NetBeans 6Abbildung 2.2: Auswahl eines Ordners zur Verbindung mit einem Projekt
Wählen Sie den Ordner nun aus und betätigen Sie den FINISH-Schalter, um diesen mit dem
Projekt zu verbinden. Der neu verbundene Ordner wird im FILESYSTEMS-Register des Explorer-
Fensters angezeigt.
Abbildung 2.3:Ein Dateiordner im Filesystems-Register
Beachten Sie, dass Ihre NetBeans-Projekte in zwei verschiedenen Ordnern
verwaltet werden. Ein Ordner speichert die Java-Dateien, im NetBeans-
Benutzerordner werden die Projekteinstellungen verwaltet.
Hello World mit NetBeans 7* ( & " ) + ! !
$ %
Nun müssen Sie den Haupt-Projektordner in das PROJECT-Register aufnehmen, damit die
(später) darin enthaltenen Dateien beim Kompilieren des Projekts mit kompiliert werden.
Wählen Sie dazu den Befehl ADD EXISTING im Kontextmenü des Projekt-Eintrags im PROJECT-
Register. Im Erscheinenden SELECT OBJECTS-Dialog können Sie ganze verbundene
Dateisysteme oder auch nur einzelne Dateien in das Projekt aufnehmen. In unserem Fall ist die
Aufnahme des gesamten Dateisystems ideal, da dort lediglich die Projekt-Hauptdateien
verwaltet werden sollen:
Abbildung 2.4: Verbinden eines Dateisystems mit dem Projekt
Dateien und Dateisysteme, die direkt mit dem Projekt verbunden sind, werden übrigens nur als
Verweis in das Projekt eingefügt.
Hello World mit NetBeans 8, - $ %
In dem neuen Projekt legen Sie nun eine Start-Klasse an.
Beachten Sie, dass es unter NetBeans (leider) eine Vielzahl an Wegen gibt, einem
Projekt eine Datei hinzuzufügen. Einige davon führen nicht zum wahrscheinlich
erwarteten Ergebnis. Ich kann hier nicht alle Wege beschreiben. Gehen Sie also
bitte genauso vor, wie ich es hier zeige.
Ein Weg, eine neue Klasse in einem Dateisystem anzulegen ist, den Befehl NEW im
Dateisystem-Eintrag im FILESYSTEMS- oder PROJECT-Register zu verwenden. Die Vorlage für
eine Starklasse finden Sie unter NEW | JAVA CLASSES | MAIN.
Abbildung 2.5: Hinzufügen einer Startklasse zu einem Dateisystem
Alternativ können Sie auch den Befehl NEW im FILE-Menü verwenden. Je nach aktiviertem
Register und aktiviertem Eintrag führt dieser Befehl aber zu verschiedenen und teilweise
falschen Möglichkeiten, eine neue Datei zu erzeugen.
Ein funktionierender Weg ist, zuvor das FILESYSTEMS-Register zu aktivieren (nicht das
PROJECT-Register!). Wählen Sie dann den Befehl NEW im FILE-Menü. Im erscheinenden NEW
WIZARD wählen Sie unter den vordefinierten Vorlagen (Templates) die Vorlage MAIN im
CLASSES-Ordner aus:
Hello World mit NetBeans 9Abbildung 2.6: Auswahl der Vorlage für die Hauptdatei einer Java-Anwendung
Hello World mit NetBeans 10Im nächsten Schritt geben Sie den Namen der neuen Klasse ein und wählen den Speicherort
(das so genannte Paket) für diese Klasse aus. (Abbildung 2.7).
Abbildung 2.7: Auswahl des Speicherorts der Datei
Wählen Sie hier den bisher einzigen Dateiordner, der ja die Projekt-Hauptdateien speichern soll.
Als Name können Sie stehen lassen. NetBeans benennt die Datei dann mit
Main.java, was für die Hauptdatei auch in Ordnung ist.
$
Da Sie nun ab hier immer wieder mit dem Begriff Paket (Package) konfrontiert werden, wollen
Sie vielleicht wissen, was ein Paket ist. Also: Pakete sind ein spezielles Java-Konzept, über das
Klassen thematisch organisiert werden. Eine Java-Datei enthält dazu die package-Anweisung,
wenn die enthaltenen Klassen einem speziellen Paket zugeordnet sein sollen:
package Paketname;
Damit können Klassen beliebigen Paketen zugeordnet werden, auch solchen, die noch gar nicht
existieren. Ein Paket ist lediglich eine logische Organisationsform. Es kann durchaus sein, dass
die Klassen eines Pakets in unterschiedlichen Dateiordnern gespeichert sind.
Durch das Paketkonzept erleichtert Java zum einen das Finden von Klassen in einer Bibliothek.
Da Pakete normalerweise thematisch organisiert sind, müssen Sie lediglich in der
Dokumentation in einem zu Ihrem Problem passenden Paket suchen, um die benötigten Klassen
zu finden. In der Java-Bibliothek sind alle Klassen z. B. in Paketen organisiert, deren Name mit
java. beginnt. Das Paket java.print enthält beispielsweise Klassen, die zum Drucken
verwendet werden. Der andere Vorteil von Paketen ist, dass so auch unterschiedliche Klassen
mit gleichen Namen verwendet werden können, sofern diese in verschiedenen Paketen verwaltet
werden.
NetBeans betrachtet nun jeden mit einem Projekt verbundenen Dateiordner als ein Paket,
obwohl das eigentlich nicht ganz korrekt ist (in einem Dateiordner können auch mehrere Java-
Dateien gespeichert sein, die unterschiedlichen Paketen zugeordnet sind). In späteren Projekten
werden Sie neben dem Ordner, der die Projektdateien enthält, auch weitere Ordner mit einem
Projekt verbinden. Diese Ordner enthalten dann eigene Bibliotheken mit vorgefertigten Klassen,
Hello World mit NetBeans 11die Sie in verschiedenen Projekten wiederverwenden. Wenn Sie dem NetBeans-Konzept folgen,
speichern Sie alle Java-Dateien, die zu einem Paket gehören, in einem separaten Ordner.
Im Feld PACKAGE können Sie nun einen eigenen Paketnamen eingeben. Wenn Sie einen
Dateiordner vor dem Hinzufügen aktiviert haben, erzeugt NetBeans eine dem Paketnamen
entsprechende Unterordner-Struktur in diesem Ordner und legt die neue Datei im letzten
Unterordner an. Haben Sie keinen Dateiordner aktiviert, wird die neue Datei in entsprechenden
Unterordnern im Default-Dateiordner (.netbeans\3.4\system im Benutzerordner) angelegt.
Übernehmen Sie für Ihre ersten Projekt-Dateien auf jeden Fall die Voreinstellung
. So arbeiten Sie zunächst nicht mit Paketen und vermeiden die
Probleme, die am Anfang daraus entstehen.
' .
In den weiteren Schritten können Sie Einstellungen für die Klasse vornehmen, die dem Moment
noch uninteressant sind. So können Sie z. B. die Basisklasse angeben, von der Sie ihre Klasse
ableiten wollen, und Eigenschaften und Methoden erzeugen. Da Sie diese Arbeiten aber
(natürlich) auch im Quellcode erledigen können, sind die weiteren Schritte eigentlich nicht
notwendig. Schließen Sie die Erzeugung der Klasse also über den FINISH-Schalter ab.
NetBeans hat nun eine entsprechende Datei in das Dateisystem eingefügt und gleichzeitig mit
dem Projekt verbunden.
Abbildung 2.8: Die neue Start-Datei im Explorer
. #
Sie können auch einen falschen Weg gehen, eine Datei hinzuzufügen. Wenn Sie vor dem
Hinzufügen den Projekt-Eintrag im PROJECT-Register aktivieren und die Datei dann über das
FILE-Menü hinzufügen, oder wenn Sie den Befehl ADD NEW im Kontextmenü des
Projekteintrags aufrufen, erhalten Sie im zweiten Schritt die zusätzliche Möglichkeit, die Datei
in das Default System einzufügen:
Hello World mit NetBeans 12Abbildung 2.9: (Falsches) Hinzufügen einer Datei in das Default-Dateisystem
Das Default-Dateisystem ist allerdings nicht (wie es zu vermuten wäre) der Projekt-Ordner,
sondern der (dem Projekt übergeordnete) Ordner .netbeans\3.4\system im Benutzerordner.
Möglicherweise ist das ein Bug, denn die NetBeans-ähnliche Entwicklungsumgebung NetBeans
verwendet den Projektordner als Default-Dateisystem.
Verwenden Sie diese Variante idealerweise nicht, da Sie Ihre Projektdateien besser
in eigenen Projektordnern verwalten sollten.
-
NetBeans hat nun eine Java-Datei mit einer Main-Klasse und einer main-Methode erzeugt:
01 /*
02 * Main.java
03 *
04 * Created on Created on 4. Januar 2003, 10:01
05 */
06
07 /**
08 *
09 * @author Administrator
10 */
11 public class Main {
12
13 /** Creates a new instance of Main */
14 public Main() {
15 }
16
17 /**
18 * @param args the command line arguments
19 */
20 public static void main(String[] args) {
21 }
22
23 }
Hello World mit NetBeans 13Wenn Sie einen eigenen Paketnamen angegeben haben, enthält diese noch eine
zusätzliche Anweisung:
package Paketname;
Damit wird diese Datei einem entsprechenden Paket zugewiesen. Lassen Sie diese Anweisung
in der Klasse stehen. Ohne eine korrekte Paketzuordnung können Sie das Programm in
NetBeans nicht starten und später auch nicht debuggen.
Wenn Sie die Datei im Projektordner verwalten, entfällt diese Zuweisung. Die Klasse wird dann
im globalen Paket verwaltet, was auch vollkommen in Ordnung ist.
$ % '
Im Projekt legt NetBeans lediglich einen Verweis auf die Datei an. Deshalb können Sie das
Programm dann aber auch über das Projekt starten.
Im FILESYSTEMS-Register des Explorers finden Sie die neue Datei, wenn Sie den verbundenen
Ordner öffnen. Sie können die Dateien eines Projekts jederzeit über das Projekt-Register oder
das FILESYSTEMS-Register des Explorers öffnen.
/ & & , '
Die automatisch erzeugte Datei enthält einige mehr oder weniger überflüssige Anweisungen.
Alle Anweisungen, die in /* und */ eingeschlossen sind, sind Kommentare. Kommentare
werden üblicherweise dazu verwendet, ein Programm zu dokumentieren, und werden vom
Compiler nicht berücksichtigt. Sie können die wenig aussagekräftigen Kommentare der neuen
Datei löschen, um mehr Übersicht zu erhalten.
Das Schlüsselwort public vor der Klassendeklaration in Zeile 11 bewirkt, dass diese Klasse
öffentlich ist. Klassen, die in Paketen organisiert sind, müssen öffentlich sein, damit sie von
außerhalb verwendet werden können.
Die Anweisungen in Zeile 14 und 15 definieren einen so genannten Konstruktor. Ein solcher
wird lediglich bei „echten“ Klassen benötigt und kann daher gelöscht werden. Auf das
Wesentliche reduziert, sieht die Klasse dann so aus:
01 public class Main
02 {
03 public static void main(String[] args)
04 {
05 }
06 }
Hello World mit NetBeans 14$ !!
$ !!
. 0
Nun können Sie programmieren. Sie werden feststellen, dass NetBeans einige hilfreiche
Features besitzt. Neben einer farblichen Unterscheidung verschiedener Schlüsselwörter
übernimmt der Editor beispielsweise das Einrücken von Programmcode fast automatisch für
Sie. Ein anderes sehr hilfreiches Feature ist, dass NetBeans mehr oder weniger automatisch alle
Möglichkeiten des aktuellen Quellcode-Kontextes anzeigt. Schreiben Sie beispielsweise nur
»Sys« und betätigen Sie danach (Strg) (Leertaste), zeigt NetBeans eine Liste mit allen
Elementen an, die mit »Sys« beginnen und im aktuellen Kontext möglich sind.
Abbildung 2.10: Die Elementliste von NetBeans
Wählen Sie das benötigte Element über die Cursortasten aus der Liste aus (für unser Beispiel ist
das der Eintrag SYSTEM) und betätigen Sie (Enter) um das Element auszuwählen. Wenn Sie den
Punkt nach einem Klassen- oder Objektnamen schreiben, öffnet sich die Liste auch automatisch.
. !
NetBeans zeigt automatisch eine und eventuell vorhandene Javadoc-Dokumentation für das in
der Auswahlliste aktiver Element an, sofern diese verfügbar ist. Javadoc-Dokumentationen
werden über spezielle Dokumentationskommentare in einem Quelltext definiert. Mit Hilfe des
Tools javadoc können Sie daraus später eine Dokumentation im HTML-Format erzeugen. Die
originale Java-Dokumentation wurde größtenteils auf diese Weise erzeugt.
NetBeans kann nun leider scheinbar eine eingebundene Java-Dokumentation nicht in der
Elementliste verwenden und verlangt nach dem Quellcode der entsprechenden Klasse.
Sie können nun den Quelltext der Java-Bibliotheksklassen als Dateisystem in das Projekt
einbinden um die Dokumentation auch in der Elementliste zu sehen. Dazu verwenden Sie
idealerweise den Javadoc Manager, den Sie im TOOLS-Menü aufrufen können. Den Quelltext
Hello World mit NetBeans 15finden Sie in der Datei src.zip im Order des Java-SDK. Ist der Quelltext eingebunden, sieht die
Anzeige z. B. so aus:
Abbildung 2.11: Die Elementliste von NetBeans mit eingebundenem Quellcode der Java-Bibliothek
Damit erhalten Sie das sehr interessante und wichtige Feature, dass NetBeans die Bedeutung
eines Elements (nach einer kurzen Wartezeit) anzeigt. Sehr interessant ist dieses Feature bei der
Verwendung von Eigenschaften und Methoden von Klassen:
Abbildung 2.12: Elementliste mit Dokumentation für die println-Methode des out-Objekts
Hello World mit NetBeans 16$ !!
Erzeugen Sie nun das einfache Programm, indem Sie über die println-Methode »Hello
World« ausgeben.
01 public class Main
02 {
03 public static void main(String[] args)
04 {
05 System.out.println("Hello World");
06 }
07 }
- !)
Sie können das Projekt nun über (Strg) (Shift) (F9) kompilieren. NetBeans kompiliert dann alle
Dateien, die zum Projekt gehören, wobei allerdings immer nur die Dateien mit einbezogen
werden, die seit dem letzten Kompilieren geändert wurden. Einzelne Dateien können Sie über
(F9) kompilieren, indem Sie diese zuvor im Explorer markieren.
Eventuelle Kompilierfehler zeigt NetBeans im »Output Window« an (Abbildung 2.13).
Abbildung 2.13: NetBeans meldet Fehler beim Kompilieren, weil aus Versehen die out-Klasse großgeschrieben
wurde
Hello World mit NetBeans 17Sehr hilfreich ist, dass NetBeans die Fehlerzeile im Quellcode markiert, wenn Sie den Fehler im
Output-Fenster anklicken.
NetBeans bietet wie viele andere Entwicklungsumgebungen neben dem
Kompilieren auch ein Erzeugen an (»to build«). Betätigen Sie dazu (Strg) (Shift)
(F11) für das gesamte Projekt und (F11) für einzelne Dateien. Der Unterschied ist,
dass ein einfaches Kompilieren nur dann erfolgt, wenn der Quellcode seit dem
letzten Kompilieren geändert wurde. Wenn Sie die Datei dagegen »erzeugen«, wird
eine eventuell bereits vorhandene .class-Datei vor dem Kompilieren gelöscht. In
einigen Fällen (vor allen Dingen in größeren Projekten), bei denen das Kompilieren
nicht zum erwarteten Ergebnis führt, weil NetBeans geänderte Dateien aus
irgendwelchen Gründen nicht kompiliert, hilft ein explizites Erzeugen.
Ist das Projekt fehlerfrei, können Sie das Programm mit (Strg) (Shift) (F6) starten, wobei auch
gleich eine Kompilierung vorgenommen wird, sofern diese notwendig ist. Beim ersten Start
müssen Sie zunächst die Klasse auswählen, mit der Ihr Programm starten soll. Diese Einstellung
wird im Projekt für spätere Starts gespeichert. Alternativ können Sie auch mit (Strg) (Shift) (F5)
starten. Mit dieser Start-Variante besitzen Sie dann die Möglichkeit, das Programm zu
debuggen, wie ich es in Kapitel 3 zeige.
Das Starten über (Strg) (Shift) (F5) oder (Strg) (Shift) (F6) funktionierte in meinem
Fall unter Linux nicht immer, wobei ich nicht herausfinden konnte, woran das lag.
Ein wiederholtes Betätigen dieser Tastekombinationen führte in einigen Fällen zum
Erfolg. In anderen Fällen konnte ich ein Programm aber nur starten, indem ich die
Startdatei im Explorer markierte und (F6) betätigte. (F6) steht für das Starten einer
einzelnen Datei, was in Projekten verwendet wird, die mehr als eine ausführbare
Datei besitzen.
Die Ausgaben einer Konsolenanwendung erscheinen nicht in einer Konsole des
Betriebssystems, sondern im »Output Window« der Entwicklungsumgebung.
1 ! /! !
$
Wenn Sie eine Klasse direkt einem verbundenen Dateiordner unterordnen, wird diese per
Voreinstellung in keinem speziellen, sondern dem globalen Paket verwaltet. Wenn Sie
allerdings Klassen in untergeordneten Ordnern erzeugen, werden diese automatisch einem Paket
zugeordnet, dessen Name vom Ordnernamen abgeleitet wird. Wenn Sie z. B. den Ordner
C:\Projekte\Java\HelloWorld (Windows) bzw. /usr/projekte/java/HelloWorld (Linux) mit
einem Projekt verbinden und darin einen Ordner Start anlegen, werden alle in diesem Ordner
angelegten Klassen dem Paket Start zugeordnet. Legen Sie in diesem Ordner einen Unterordner
mit dem Namen Main an, werden die darin enthaltenen Klassen dem Paket Start.Main
zugeordnet. Das Ganze ist etwas kompliziert, aber leider notwendig zu wissen, denn:
Wenn Sie externe Klassen in ein Projekt integrieren, müssen Sie auf eine korrekte
Einstellung des Paketnamens achten. Entspricht der Paketname nicht der Ordner-
Hierarchie, erzeugt NetBeans (bzw. der Java-Compiler) beim Kompilieren den
Fehler, dass das angegebene Paket nicht gefunden werden konnte.
Hinzu kommt, dass Paketnamen keine Leerzeichen und andere Sonderzeichen beinhalten
dürfen. Die Ordner müssen also entsprechend benannt sein.
Hello World mit NetBeans 18Wenn Sie bereits andere Java-Programme besitzen oder diese mit einer anderen
Entwicklungsumgebung entwickeln, müssen Sie die entsprechenden Ordner zur Ausführung
dieser Programme in NetBeans mit einem neuen oder vorhandenen Projekt verbinden und die
package-Anweisung in diesen Programmen entsprechend anpassen.
2 $ %
Wenn Sie externe Projekte in NetBeans integrieren wollen, gehen Sie folgendermaßen vor:
• Speichern Sie die Java-Dateien in einem Ordner Ihrer Festplatte, falls das noch nicht der
Fall ist,
• legen Sie in NetBeans ein neues Projekt an,
• verbinden Sie den Ordner der Java-Dateien im FILESYSTEMS-Register des Explorers mit
diesem Projekt,
• wechseln Sie zum Projekt-Register des Explorers,
• klicken Sie mit der rechten Maustaste auf den Projekteintrag und wählen Sie den Befehl
ADD EXISTING,
• wählen Sie im erscheinenden Dialog die Klassen aus, die im verbundenen Dateiordner
gespeichert sind. Sie können den gesamten Dateiordner oder mehrere einzelne Klassen
auswählen, indem Sie beim Klicken mit der Maus (Strg) betätigen. Alternativ können Sie
die erste Klasse auswählen, (Shift) betätigen und danach auf die letzte Klasse klicken,
• betätigen Sie den OK-Schalter, um Ihre Auswahl zu bestätigen,
• falls Ihr Projekt mehrere Klassen enthält, klicken Sie die Start-Klasse nun im Explorer mit
der rechten Maustaste an und wählen Sie den Befehl SET AS PROJECT MAIN CLASS im
TOOLS-Menü des Kontextmenüs.
Wenn Sie das Projekt nun mit (Strg) (Shift) (F5) starten, müsste alles funktionieren.
Hello World mit NetBeans 19* '. , ' !
. +& 3. !
NetBeans stellt zur Entwicklung einer Anwendung mit grafischer Oberfläche einen grafischen
Editor zur Verfügung, der die Arbeit gegenüber der Erzeugung dieser Oberflächen im
Quellcode erheblich vereinfacht.
Als Beispiel verwende ich eine Nettoberechnung, die aus einem gegebenen Bruttobetrag und
einem Steuerwert einen Nettobetrag errechnen soll.
Java ist sehr komplex im Bereich der Programmierung von und mit Formularen
und Steuerelementen. Ich kann aus Platzgründen hier nur einen kleinen Ausschnitt
der Möglichkeiten zeigen. Damit sind Sie aber in der Lage, einfache Anwendungen
mit einer grafischen Oberfläche zu entwickeln. Halten Sie sich möglichst an meine
Anleitung, damit beim Programmieren nicht allzu viel daneben geht.
Ein erster Hinweis folgt direkt hier: NetBeans funktioniert leider nicht immer
zuverlässig. Neben dem scheinbar in einigen Fällen zu großen Ressourcen-Hunger,
der dazu führen kann, dass andere Programme oder das ganze System (wenigstens
unter Windows) abstürzen, werden Sie u. U. bei der Arbeit mit dem Formular- oder
dem Quellcodeeditor Probleme haben. Es kann dabei schon einmal passieren, dass
das Markieren von Steuerelemente über die Maus oder die Eingabe von Quellcode
nicht möglich ist. In einigen Fällen hilft dann ein wiederholtes Öffnen der
entsprechenden Daten. Manchmal müssen Sie aber NetBeans komplett neu starten,
um sinnvoll weiterarbeiten zu können.
Hello World mit NetBeans 204 $ %
!
Zur Entwicklung einer Anwendung mit grafischer Oberfläche erzeugen Sie zunächst ein neues
Projekt, das Sie vielleicht Nettoberechnung nennen. Verbinden Sie dann einen neuen Ordner
Nettoberechnung, den Sie in Ihrem Projekte-Ordner anlegen, mit diesem Projekt. Nun fügen Sie
dem Projekt ein neues Fenster hinzu. Wählen Sie dazu im New Wizard die Vorlage JFRAME aus
dem Ordner GUI FORMS (Abbildung 2.14).
Abbildung 2.14: Auswahl eines JFrame-Formulars für eine Java-Anwendung
Ein JFrame ist ein normales Fenster mit einem in der Größe veränderbaren Rahmen.
Nachdem Sie den NEXT-Schalter betätigt haben, geben Sie im nächsten Schritt noch einen
Namen ein. Nennen Sie das Formular vielleicht StartFrame. Die folgenden Schritte können Sie
übergehen, indem Sie einfach den FINISH-Schalter betätigen.
Wenn das Formular hinzugefügt wurde, zeigt die Entwicklungsumgebung direkt den Form
Editor an, mit dem Sie das Formular bearbeiten können. Diesen Editor erreichen Sie auch,
indem Sie im Explorer auf das Formular doppelklicken. In einem zweiten Fenster wird eventuell
der Quellcode des Formulars angezeigt. Diesen sollten Sie zunächst ignorieren. Java-Formulare
werden komplett als Quellcode implementiert. Damit haben Sie aber nicht viel zu tun, wenn Sie
eine Entwicklungsumgebung verwenden. Diese bietet Ihnen einen einfachen Formular-Editor,
den Sie mit der Maus bearbeiten können, und übernimmt die Erzeugung des Quellcodes
automatisch für Sie.
Hello World mit NetBeans 21Abbildung 2.15: Der Formulareditor von NetBeans
5 ' 0 !
Als Erstes müssen Sie eine Einstellung ändern, damit Sie das Formular auf die
gewohnte Weise entwerfen können. Java-Formulare arbeiten nämlich mit ziemlich
komplizierten so genannten Layout-Managern, die das Layout eines Formulars
automatisch einstellen. Der voreingestellte Layout-Manager flowLayout sorgt
dafür, dass Ihre Steuerelemente immer automatisch auf die maximal mögliche
Größe vergrößert werden. Und das ist (wenigstens am Anfang ...) eher störend als
hilfreich. Klicken Sie zur Änderung des Layout-Managers mit der rechten
Maustaste auf das Formular und wählen Sie den Befehl SET LAYOUT. Wählen Sie
dann den Eintrag Null Layout (was dafür steht, dass kein Layout-Manager
verwendet wird).
Nun können Sie Steuerelemente auf dem Formular ablegen. Die Standard-Steuerelemente
finden Sie im oberen Bereich des Formulareditors im Register SWING. Das erste Steuerelement
in der Reihenfolge ist ein Label (JLabel) zur Beschriftung, das zweite ein normaler Schalter
(JButton). Das neunte Steuerelement (JTextField) ist eine Textbox.
Platzieren Sie drei Label, drei Textboxen und zwei Schalter auf dem Formular, indem Sie diese
in der Toolbox anklicken und danach auf dem Formular klicken. Platzieren Sie diese
Steuerelemente und stellen Sie die Größe ein, bis das Formular in etwa so aussieht wie in
Abbildung 2.16.
Hello World mit NetBeans 22Abbildung 2.16: Das Formular zur Nettoberechnung in einer ersten Rohfassung
Sie können die Steuerelemente auch auf dem Formular markieren und über (Strg)
(c) in die Zwischenablage kopieren. Mehrer Steuerelemente markieren Sie, indem
Sie beim Klicken (Shift) betätigen. Das Einfügen mit (Strg) (v) funktioniert aber
nur, wenn kein Steuerelement markiert ist. Klicken Sie dazu vor dem Einfügen auf
einen freien Bereich des Formulars. Die eingefügten Steuerelemente werden über
den Quell-Steuerelementen angelegt, so dass es so aussieht, als ob nichts passiert
wäre. Ziehen Sie das eingefügte Steuerelement dann einfach an seinen Platz.
6 .
Nun müssen Sie zunächst einige Eigenschaften der Steuerelemente einstellen. Die wichtigste ist
einmal wieder der Name der Steuerelemente. Wählen Sie die Steuerelemente dazu einzeln aus
und klicken Sie im Eigenschaften-Fenster auf das Register CODE GENERATION. Den Namen
stellen Sie in der Eigenschaft VARIABLE NAME ein (Abbildung 2.17).
Abbildung 2.17: Einstellung der Eigenschaft Variable Name für die erste Textbox
Vergeben Sie wieder sinnvolle Namen. Ich verwende die Namen txtBrutto, txtSteuer, txtNetto,
btnRechnen und btnBeenden. Die Label benenne ich nicht, weil ich diese im Programm nicht
anspreche.
Hello World mit NetBeans 23Nun stellen Sie noch den Text der Label, der Schalter und der Textfelder ein. Wählen Sie dazu
das Register PROPERTIES im Eigenschaftenfenster und schreiben Sie entsprechende Werte in die
Eigenschaft Text. Das Ergebnis soll so aussehen wie in Abbildung 2.18.
Abbildung 2.18: Das Formular zur Nettoberechnung im fertigen Entwurf
Stellen Sie dann die Eigenschaft title des Formulars ein, indem Sie auf einem freien Bereich
des Formulars klicken und die Eigenschaft im PROPERTIES-Register des Eigenschaftenfensters
suchen. Als Titel bietet sich natürlich »Nettoberechnung« an.
( 7 0 ! ! . '
Abschließend sollten Sie noch dafür sorgen, dass das Formular beim Start nicht automatisch
verkleinert wird, was ansonsten der Fall wäre. Bei markiertem Formular klicken Sie dazu auf
das Register CODE GENERATION des Eigenschaftenfensters. Setzen Sie die Eigenschaft FORM
SIZE POLICY auf GENERATE RESIZE CODE. Nun wird Ihr Formular immer auf die Größe
eingestellt, die Sie in der Entwicklungsumgebung festlegen. Bei der Höhe müssen Sie allerdings
die Höhe der hinzukommenden Titelleiste mit einrechnen. Gestalten Sie Ihr Formular also etwas
höher als notwendig.
8 $ !!
Nun können Sie programmieren. Dazu klicken Sie wieder einfach doppelt auf den RECHNEN-
Schalter. Alternativ können Sie die notwendige Methode auch über das Kontextmenü des
Schalters erzeugen. Markieren Sie den Schalter, klicken Sie mit der rechten Maustaste darauf
und wählen Sie den Befehl EVENTS / ACTION / ACTIONPERFORMED.
8 9 &
Die Entwicklungsumgebung erzeugt automatisch eine Methode zur Behandlung des Ereignisses
»Betätigung des Schalters« und zeigt den Quellcode des Formulars an.
Lassen Sie sich nicht von dem komplizierten Code verwirren. Das, was Sie dort
sehen, gehört bereits zu den erweiterten objektorientierten Techniken. Für Sie ist
zunächst lediglich wichtig, was Sie innerhalb der automatisch erzeugten Methoden
programmieren.
Hello World mit NetBeans 24Abbildung 2.19: Der Quellcode-Editor von NetBeans mit einer Methode für die Betätigung des Rechnen-Schalters
Die blau hinterlegten Bereiche stellen Quellcode dar, der von der Entwicklungsumgebung
automatisch erzeugt wird und den Sie gar nicht bearbeiten können. So können Sie auch weniger
Fehler machen. Nur den Quellcode in den weißen Bereichen können Sie bearbeiten.
Die im unteren Bereich von Abbildung 2.19 sichtbare main-Methode zeigt
übrigens, wie eine solche Anwendung startet, nämlich im Prinzip genau wie eine
Konsolenanwendung. Nur dass hier das Formular erzeugt und geöffnet wird. Aber
das gehört auch schon zu den erweiterten Techniken.
8 $ !! .
Innerhalb der Methode btnRechnenActionPerformed können Sie nun programmieren. Zur
Programmierung einer Nettoberechnung benötigen Sie zunächst drei Variablen. In Java-
Programmen deklarieren Sie diese einfach da, wo Sie sie benötigen:
01 private void btnRechnenActionPerformed(java.awt.event.ActionEvent evt) {
02 /* Deklaration der benötigten Variablen */
03 double brutto;
04 double steuer;
05 double netto;
Nun können Sie die eingegebenen Daten einlesen. Die Methode getText gibt das, was in der
Textbox gespeichert ist, als Text zurück. Eingaben müssen Sie in Java konvertieren. Dazu
Hello World mit NetBeans 25verwenden Sie die Java-Methode Double.parseDouble, der Sie den zu konvertierenden Text
übergeben und die die konvertierte Zahl zurückgibt:
06 brutto = Double.parseDouble(txtBrutto.getText());
07 steuer = Double.parseDouble(txtSteuer.getText());
Nun folgen nur noch die Berechnung:
08 netto = brutto * (1 - (steuer / (100 + steuer)));
und die Ausgabe des Ergebnisses. Da Java eine typsichere Sprache ist, müssen Sie die Zahl nun
wieder in einen Text konvertieren, damit Sie diesen in die Textbox schreiben können. Leider
stellt Java keine einfache Funktion dazu zur Verfügung. Der Quellcode zur Umwandlung und
Formatierung einer Zahl sieht deshalb etwas kompliziert aus:
09 java.text.DecimalFormat df = new java.text.DecimalFormat("0.00");
10 txtNetto.setText(df.format(netto));
11 }
Zunächst erzeugen Sie in Zeile 9 ein Objekt der Klasse DecimalFormat. Dieses spezielle
Objekt wird in Java dazu verwendet, dezimale Zahlen zu formatieren. Dazu verwenden Sie (in
Zeile 10) die format-Methode, der Sie das Format als Zeichenkette übergeben. »0.00« steht
dabei für eine Zahl mit führender Null und zwei Dezimalstellen. Das Ergebnis dieser Methode
schreiben Sie über die Methode setText in das Ergebnis-Textfeld.
8 $ !! .
Nun müssen Sie nur noch die Methode für den BEENDEN-Schalter programmieren. Klicken Sie
im Formulareditor doppelt auf diesen Schalter, um eine Methode zu erzeugen, die auf die
Betätigung des Schalters reagiert. Programmieren Sie dann die folgende Anweisung:
12 private void btnBeendenActionPerformed(java.awt.event.ActionEvent evt)
13 dispose();
14 }
Damit ist die Programmierung abgeschlossen und Sie können das Programm testen.
: ; $ !!
Nun können Sie das Programm testen. Starten Sie das Projekt wie bei einer
Konsolenanwendung mit (Shift) (Strg) (F6). Beim ersten Start müssen Sie wieder die Projekt-
Startklasse angeben. Wenn der Compiler dann keine Fehler meldet, öffnet sich nach einer
kurzen Zeit das Formular und Sie können Zahlen eingeben und rechnen (Abbildung 2.20).
Hello World mit NetBeans 26Abbildung 2.20: Das Nettoberechnungs-Programm unter Linux
, ! & &
Wenn Sie beim Testen ungültige Zahlen oder nichts eingeben und den RECHNEN-Schalter
betätigen, erzeugt der Java-Interpreter eine so genannte Ausnahme. Diese wird allerdings
lediglich im Output Window von NetBeans gemeldet. Das Programm läuft nach der Ausnahme
einfach weiter. Wenn Sie das Programm direkt über den Java-Interpreter starten, wird die
Ausnahme ebenfalls direkt in der Konsole gemeldet. In Real-World-Programmen sollten Sie
solche Ausnahmen abfangen. Zurzeit müssen Sie sich noch mit der einfachen Meldung in der
Konsole begnügen.
! < !)
Wenn Sie ein Formular mit NetBeans entwickeln und kompilieren, erzeugt die
Entwicklungsumgebung mehrere .class-Dateien. In meinem Fall wurden z. B. die Dateien
StartForm.class, StartForm$1.class, StartForm$2.class und StartForm$3.class erzeugt. Alle
diese Dateien sind notwendig, wenn Sie das Programm über den Java-Interpreter (z. B. auf
einem anderen Rechner) ausführen wollen. Was die Entwicklungsumgebung damit bezweckt,
konnte ich allerdings nicht herausfinden.
Hello World mit NetBeans 27. &
Nun, da Sie bereits einfache Programme schreiben können, werden Sie wohl auch den einen
oder anderen Fehler machen. NetBeans integriert einen sehr guten Debugger, den Sie relativ
einfach nutzen können um diese Fehler zu finden und zu beseitigen. Dieser Debugger ist sehr
mächtig und bietet viele spezielle Features zur Fehlersuche. Am Anfang und auch eigentlich in
den meisten Fällen in der Praxis reichen einfache, grundlegende Techniken aber aus. Und diese
beschreibe ich hier.
1
, ! . 0
Die beiden Fehlerarten, die Sie debuggen müssen, sind Ausnahmen und logische Fehler.
Ausnahmen treten ein, wenn Ihr Programm auf einen Fehler trifft, der eine weitere Ausführung
verhindert. Wenn Sie beispielsweise eine Datei einlesen wollen, und diese Datei ist nicht
vorhanden, tritt beim Versuch, die Datei zu öffnen, eine Ausnahme ein. Eine andere Ausnahme
haben Sie bereits im Nettoberechnungsprogramm für den Fall kennen gelernt, dass die Eingaben
des Anwenders nicht in eine Zahl konvertiert werden können. Ausnahmen können Sie abfangen,
was ich hier allerdings nicht beschreibe. Nicht abgefangene Ausnahmen führen dazu, dass das
Programm im Debugger anhält.
Ausnahmen sind meist recht einfach zu debuggen, weil der Debugger direkt an der Anweisung
anhält, die die Ausnahme verursacht hat. Viel schwieriger ist dagegen das Finden logischer
Fehler. Diese Fehler führen in der Regel nicht zu Ausnahmen, sondern zu einem Fehlverhalten
des Programms. Wenn Sie beispielsweise die Berechnung des Bruttobetrags in der
Bruttoberechnungs-Anwendung falsch programmiert haben, wird lediglich ein falsches
Ergebnis ausgegeben. In einigen Fällen führen logische Fehler auch in nachfolgenden
Anweisungen zu Ausnahmen, beispielsweise, wenn der Name einer zu öffnenden Datei im
Programm dynamisch ermittelt wird, aber das entsprechende Teilprogramm fehlerhaft arbeitet.
Die Ursache eines logischen Fehlers zu finden ist in größeren Programmen recht schwierig, weil
Sie nicht genau wissen, welche Anweisung den Fehler verursacht hat.
" )
Zum Lokalisieren logischer Fehler können Sie in fast allen Entwicklungsumgebungen im
Quellcode so genannte Haltepunkte setzen. Ein Haltepunkt bewirkt, dass der Debugger das
Programm bei der Ausführung anhält. Haltepunkte setzen Sie dort, wo Sie die Ursache eines
logischen Fehlers vermuten. Das kann auch durchaus eine Anweisung sein, die ganz am Anfang
eines Programms steht. Ein Debugger bietet immer die Möglichkeit, ein angehaltenes
Programm schrittweise weiter auszuführen und dabei die Inhalte von Variablen zu beobachten.
So können Sie logische Fehler recht einfach finden und beseitigen. Die folgenden Abschnitte
zeigen nun, wie Sie diese Technik in NetBeans nutzen. Ich gehe dabei nicht auf Ausnahmen ein,
sondern nur auf logische Fehler. Ausnahmen können Sie prinzipiell auf dieselbe Art debuggen.
Einfaches Debuggen 28)
Um ein sinnvolles Beispiel für das Debugging zu verwenden, setze ich ein Programm ein, das
ermitteln soll, ob eine Zahl eine Primzahl ist. Das Programm arbeitet fehlerhaft. Zahlen, die
eindeutig Primzahlen sind, werden nicht als solche erkannt:
01 public class Main
02 {
03 public static void main(String args[])
04 {
05 int zahl = 7, teiler;
06 boolean primzahl = false;
07
08 for (teiler = 2; teiler. &
In NetBeans setzen Sie zum Debuggen einen Haltepunkt, indem Sie im Quellcode-Editor in der
Zeile, an der der Debugger anhalten soll, mit der Maus in der linken grauen Spalte klicken. Zum
Debuggen des Primzahlen-Programms sollten Sie den Haltepunkt in einer Anweisung oberhalb
der Schleife setzen, da diese mit ziemlich großer Wahrscheinlichkeit den Fehler verursacht.
Wenn Sie das Programm nun ausführen ((Alt) (F5)), hält der Debugger am Haltepunkt an
(Abbildung 3.1).
Abbildung 3.1: Der NetBeans-Debugger hat das Programm an einem Haltepunkt angehalten
Sie können das Programm nun mit (F8) schrittweise weiter ausführen. (F8) führt dazu, dass das
Programm bei eventuell aufgerufenen eigenen Funktionen nicht in diese hineinspringt. Mit (F7)
würde der Debugger auch in Funktionen hineinspringen, damit Sie diese ebenfalls debuggen
können.
=& ' . .
Beim schrittweisen Durchgehen sollten Sie die Inhalte von Variablen beobachten. Dazu können
Sie den Mauscursor einfach auf eine Variable im Editor bewegen. NetBeans zeigt den Inhalt
nach einer kurzen Wartezeit automatisch an. Besser ist jedoch in den meisten Fällen, einen so
genannten Überwachungsausdruck (englisch: Watch) anzulegen. Betätigen Sie dazu (Strg)
(Shift) (F7) und geben Sie den Namen einer zu überwachenden Variablen ein. Für unser Beispiel
eignen sich die Variablen zahl und teiler. NetBeans erlaubt zudem, komplexe Ausdrücke zur
Überwachung einzugeben. Legen Sie also einen neuen Überwachungsausdruck zahl %
teiler an, um das jeweilige Ergebnis der Restwert-Division beobachten zu können. Wenn Sie
nun schrittweise durch das Programm gehen, sehen Sie in jedem Schleifendurchlauf im
»Watches«-Fenster die aktuellen Inhalte der Variablen und das Ergebnis des arithmetischen
Ausdrucks.
Einfaches Debuggen 30Abbildung 3.2: Das Watches-Fenster beim letzten Schleifendurchlauf Beim letzten Schleifendurchlauf erkennen Sie, dass die Restwert-Division Null ergibt. Das Programm verzweigt dann auch zur Anweisung, die die Variable primzahl auf false setzt. Den Fehler haben Sie auf diese Weise recht schnell lokalisiert: Die Schleife zählt den Teiler bis zu der zu prüfenden Zahl selbst hoch, da der Vergleich des Teilers mit der Zahl fälschlicherweise mit
;))
,&
NetBeans kennt Abkürzungen für vordefinierte Anweisungsteile. Schreiben Sie z. B. »impa«
und betätigen Sie die Leertaste, ersetzt NetBeans diese Abkürzung durch »import java.awt.«.
Sie erreichen die vordefinierten Abkürzungen über die Optionen (TOOLS | OPTIONS):
Abbildung 4.1: Die Optionen für Abkürzungen
Tipps 32Über den Schalter mit den drei Punkten in der Option ABBREVIATIONS öffnen Sie die
Abkürzungsliste:
Abbildung 4.2: Die Abkürzungen
Über den ADD-Schalter können Sie eigene Abkürzungen hinzufügen (z. B. »p« für
»System.out.println«).
Die vordefinierten Abkürzungen finden Sie im Anhang.
Tipps 33* ,
* # . ; !&
> . ( '
Tasten Bedeutung
(Strg) (S) Speichern der aktuellen Datei
(ALT) (F1) Kontextsensitive Anzeige der Javadoc-Dokumentation des
aktuellen Elements
Tabelle 5.1: Die wichtigen NetBeans-Tastenkombinationen zur Verwaltung eines Projekts
$ % '
Tasten Bedeutung
(Strg) (S) Speichern der aktuellen Datei
(Strg) (2) Explorer in einem Register anzeigen, in dem dieser nicht sichtbar
ist
(Strg) (3) Quellcode-Editor in einem Register anzeigen, in dem dieser nicht
sichtbar ist
Tabelle 5.2: Die wichtigen NetBeans-Tastenkombinationen zur Verwaltung eines Projekts
- !)
Tasten Bedeutung
(Strg) (Shift) (F9) Kompilieren des Projekts. Der Compiler kompiliert dabei nur
Dateien, die seit dem letzten Kompilieren geändert wurden.
(Strg) (Shift) (F11) Erzeugen des Projekts. Der Compiler kompiliert dabei alle
Dateien, auch wenn diese seit dem letzten Kompilieren nicht
geändert wurden.
(F9) Kompilieren der aktuell markierten Quellcodedatei oder aller
Dateien in einem verbundenen Dateiordner (ohne die in
Unterordnern gespeicherten)
(Shift) (F9) Kompilieren aller Quellcodedateien eines verbundenen
Dateiordners inklusive den in Unterverzeichnissen gespeicherten
(F11) Erzeugen der aktuell markierten Quellcodedatei oder aller
Dateien in einem verbundenen Dateiordner (ohne die in
Unterordnern gespeicherten)
(Shift) (F11) Erzeugen aller Quellcodedateien eines verbundenen Dateiordners
inklusive den in Unterverzeichnissen gespeicherten
(Strg) (Shift) (F5) Ausführen des Projekts inklusive Kompilieren zum Debuggen
(Strg) (Shift) (F6) Ausführen des Projekts inklusive Kompilieren ohne Debuggen
(Alt) (F5) Ausführen der aktuell ausgewählten Klasse
Anhang 34Tabelle 5.3: Die wichtigsten NetBeans-Tastenkombinationen zum Kompilieren und Starten eines
Programms
&
Tasten Bedeutung
(Strg) (Shift) (F5) Ausführen des Projekts inklusive Kompilieren zum Debuggen
(Alt) (F5) Ausführen der aktuell ausgewählten Klasse
(F8) Schrittweises Ausführen des Programms. (F8) springt im
Gegensatz zu (F7) nicht in aufgerufene Funktionen/Methoden
hinein.
(F7) Schrittweises Ausführen des Programms. (F7) springt im
Gegensatz zu (F8) auch in aufgerufene Funktionen/Methoden
hinein.
(F4) Programm weiter bis zur Cursorposition ausführen
(Alt) (Shift) (F7) Schrittweises Ausführen des Programms bis zu der
Quellcodezeile, die dem Aufruf der aktuellen Methode folgt
(Heraussprung aus einer Methode)
(Shift) (F5) Ausführung des Programms beenden
(Strg) (Shift) (F7) Überwachungsausdruck (Watch) anlegen
(Strg) (F5) Debugger-Fenster anzeigen
Tabelle 5.4: Wichtige Tastenkombinationen beim Debuggen in NetBeans
* ( ,&
Die vordefinierten Abkürzungen finden Sie in der NetBeans-Dokumentation im Anhang:
editor.netbeans.org/doc/UserView/apdx_b_abbrevs.html.
Abkürzung wird ersetzt durch
en Enumeration
ex Exception
gr Graphics
ob Object
psf public static final
psfb public static final boolean
psfi public static final int
psfs public static final String
re Rectangle
st String
ve Vector
ab abstract
bo boolean
Anhang 35Sie können auch lesen
