Jürgen Bayer. Java-Entwicklung mit NetBeans 3.4

Transkript

1 Jürgen Bayer Java-Entwicklung mit NetBeans 3.4

2 Inhaltsverzeichnis 1 Einführung Installation Der Benutzerordner Starten von NetBeans Integration der Java-Dokumentation 2 2 Hello World mit NetBeans Erzeugung eines neuen Projekts Projekte Was Sie über verbundene Dateien wissen sollten Erzeugen eines neuen Projekts Verbinden des Projekt-Hauptordners Verbinden des Haupt-Ordners mit dem Projekt Anlegen einer Start-Klasse für das Projekt Programmieren und Starten des Programms Nützliche Features Javadoc-Dokumentation Das erste Programm Kompilieren und Starten Grundlagen zum Umgang mit NetBeans Pakete Integration von externen Projekten Entwickeln einer Anwendung mit grafischer Oberfläche mit NetBeans Erzeugen des Projekts und des Startformulars Entwurf des Formulars Einstellen der Eigenschaften Programmieren Methode zur Ereignisbehandlung erzeugen Programmierung der Berechnung Programmieren des Beenden-Schalters Testen des Programms Die vom Compiler erzeugten Dateien 27 3 Einfaches Debuggen 28

3 3.1 Grundlagen Ausnahmen und logische Fehler Haltepunkte Ein Beispiel Einfaches Debuggen Überwachungsausdrücke 30 4 Tipps Abkürzungen 32 5 Anhang Wichtige NetBeans-Tastenkombinationen Vordefinierte Abkürzungen 35 6 Index 38

4 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 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 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\<benutzername>\.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 1

5 Installation 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

6 "#! 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

7 $% 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 4

8 Beim 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

9 $% 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 6

10 Abbildung 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

11 * (&" )+!! $% 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

12 ,-$% 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 9

13 Abbildung 2.6: Auswahl der Vorlage für die Hauptdatei einer Java-Anwendung Hello World mit NetBeans 10

14 Im 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 <default name> 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 11

15 die 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 <default name>. 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 12

16 Abbildung 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 */ /** 08 * 09 Administrator 10 */ 11 public class Main { /** Creates a new instance of Main */ 14 public Main() { 15 } /** 18 args the command line arguments 19 */ 20 public static void main(string[] args) { 21 } } Hello World mit NetBeans 13

17 Wenn 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

18 $!! $!!.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 15

19 finden 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

20 $!! 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 17

21 Sehr 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 18

22 Wenn 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

23 * '.,'!.+&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 20

24 4 $%! 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 21

25 Abbildung 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 Hello World mit NetBeans 22

26 Abbildung 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 23

27 Nun 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 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. (70!!. ' 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 24

28 Abbildung 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 25

29 verwenden 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 26

30 Abbildung 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

31 .& 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

32 ) 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; for (teiler = 2; teiler <= zahl; teiler++) 09 { 10 if (zahl % teiler == 0) 11 primzahl = false; 12 } if (primzahl) 15 System.out.println(zahl + " ist eine Primzahl"); 16 else 17 System.out.println(zahl + " ist keine Primzahl"); 18 } 19 } Einfaches Debuggen 29

33 .& 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 30

34 Abbildung 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 <= und nicht mit < erfolgt, und teilt im letzten Durchlauf die Zahl durch sich selbst. Wenn Sie den Fehler dann gefunden haben, können Sie diesen gleich beseitigen. Beachten Sie dabei, dass der Debugger diese Änderungen nicht berücksichtigt, so lange Sie das Programm weiter testen. Führen Sie das Programm also mit (Strg) (F5) zu Ende aus und starten Sie dieses erneut, um zu überprüfen, ob der Fehler beseitigt ist. Einfaches Debuggen 31