3.2 Eclipse

• 3.2 Eclipse
  • 3.2.1 Überblick
  • 3.2.2 Installation
  • 3.2.3 Erste Schritte

3.2.1 Überblick

Eclipse ging ursprünglich aus Visual Age for Java hervor, einer Entwicklungsumgebung von IBM, deren Sourcecode 2001 der Eclipse Foundation übergeben wurde. Mit diesem Schritt wurde der Markt der Entwicklungsumgebungen mit einem Schlag nachhaltig verändert. Eclipse war von nun an unter der offenen EPL (Eclipse Public License) frei verfügbar und tat sich durch eine Reihe innovativer Funktionen hervor, die bis dahin den kostenpflichtigen IDEs vorbehalten waren. Eclipse wird seitdem von einer starken Community getragen und unermüdlich weiterentwickelt, auch von vielen namhaften Firmen der Branche.

Eclipse selbst ist in Java entwickelt und steht für Windows, Linux und Mac OS X zur Verfügung. Die Eclipse IDE besteht aus der sogenannten »Plattform« und der eigentlichen IDE, die auf der Plattform gründet. Eclipse unterstützt auch andere Programmier- und Skriptsprachen (beispielsweise C/C++ oder PHP) und ist aufgrund seiner offenen Architektur sehr flexibel.

3.2.2 Installation

Sie können Eclipse von der Buch-DVD oder von der offiziellen Projektseite unter http://www.eclipse.org/downloads herunterladen. Wählen Sie auf der Internetseite gegebenenfalls das Paket »Eclipse IDE for Java Developers« aus und beachten Sie, dass Eclipse eine vorinstallierte Java-Runtime-Umgebung benötigt. Wie diese zu installieren ist, können Sie in Abschnitt 2.1.2 nachlesen.

Im Folgenden wird die Installation unter Windows beschrieben. Legen Sie dazu einfach ein Verzeichnis an, in dem Sie Eclipse ablegen möchten, z.B. c:\Programme\Eclipse. Entpacken Sie in diesem Verzeichnis die heruntergeladene Datei, z.B mit Filzip oder mit WinZip. Legen Sie nun ein weiteres Verzeichnis an, in dem Eclipse die Quelltexte aller Projekte verwalten soll, z.B. c:\workspace. Dies ist der sogenannte Workspace.

3.2.3 Erste Schritte

Starten Sie anschließend das Programm eclipse.exe aus dem Installationsverzeichnis. Um in Zukunft die IDE bequemer starten zu können, können Sie eine Verknüpfung anlegen und diese auf Ihren Desktop legen. Wenn Sie beim ersten Start nach dem Ort Ihres Workspace gefragt werden, geben Sie c:\workspace an.

Abbildung 3.1: Auswahl des Workspace

Nun startet die Eclipse IDE mit einem Willkommensbildschirm, den Sie einfach schließen, anschließend kommt die Arbeitsoberfläche zum Vorschein, wie ihn die nächste Abbildung zeigt. Diese Arbeitsfläche heißt Perspektive; konkret befinden Sie sich zunächst auf der Java-Perspektive. Perspektiven lassen sich über die Togglebuttons oben rechts wechseln. Anfangs befindet sich dort nur ein Togglebutton, nämlich der für die Java-Perspektive.

Die Java-Perspektive teilt sich in vier Bereiche auf, in denen sich die sogenannten »Views« befinden. Links sehen Sie beispielsweise die Package Explorer View und unten befindet sich eine View, die eine Liste mit Compiler-Fehlern zeigt. Die Perspektiven und Views lassen sich nach Belieben konfigurieren.

Abbildung 3.2: Die Eclipse IDE nach dem ersten Öffnen

Nachdem wir uns mit der Oberfläche ein wenig vertraut gemacht haben, wollen wir im Folgenden mit Hilfe des HelloWorld-Programms (siehe Listing 2.1) etwas tiefer in die Features der IDE einsteigen und die folgenden beiden Schritte ausführen:

• Da die Arbeiten in Projekten organisiert sind, legen wir zunächst ein neues Java-Projekt an.
• Innerhalb des neu angelegten Projekts legen wir die neue Java-Klasse an, implementieren diese und experimentieren ein wenig mit ihr herum.

Bewegen Sie zunächst die Maus in den Package Explorer und öffnen Sie per Rechtsklick das Kontextmenü. Wählen Sie »New« und »Java-Project« und geben Sie im folgenden Dialog den Namen für das Projekt ein, z.B. HelloWorld. Bestätigen Sie Ihre Eingaben, indem Sie den Dialog über »Okay« verlassen.

In der Baumstruktur des Package Explorers sehen Sie das neue HelloWorld-Projekt. Klappen Sie nun den Knoten des Baums auf. Eclipse hat darin bereits einen src-Ordner angelegt, der Ausgangspunkt für alle Klassen des Projekts ist.

Als Nächstes legen wir die Klasse HelloWorld an, und zwar der Einfachheit halber direkt im Default-Package, also direkt im src-Verzeichnis selbst, nicht in einem seiner Unterverzeichnisse. Öffnen Sie dazu auf dem src-Verzeichnis das Kontextmenü per rechtem Mausklick und wählen Sie »New« und »Class«. Nun öffnet sich ein Wizard, in dem Sie als Klassennamen HelloWorld eingeben. Bestätigen Sie Ihre Eingaben, indem Sie den Dialog über »Okay« verlassen.

Eclipse hat nun wie erwartet die Datei HelloWorld.java angelegt:

001 public class HelloWorld { 002 003 }

Listing 3.1: HelloWorld nach dem Anlegen der Klasse durch den Wizard

Das Syntaxhighlighting hebt die Schlüsselwörter public und class farblich und durch Fettschrift hervor; der Code lässt sich dadurch leichter lesen.

Eclipse bietet einige hilfreiche vorkonfigurierte Codevervollständigungen, die mit dem Tastenkürzel [STRG]+[LEER] ausgelöst werden können. Setzen Sie dazu den Cursor in den Klassenrumpf (in Zeile 002 von Listing 3.1) und geben Sie main ein. Drücken Sie direkt nach der Eingabe [STRG]+[LEER]. Nun öffnet sich ein Kontextmenü, das die Möglichkeit bietet, eine main-Methode zu generieren. Nach Drücken von [ENTER] wird die Methode generiert.

001 public class HelloWorld { 002 public static void main(String[] args) { 003 004 } 005 }

Listing 3.2: HelloWorld nach dem Erzeugen der main-Methode

Setzen Sie anschließend den Cursor in den Rumpf der main-Methode (in Zeile 003 von Listing 3.2). Wenn Sie sysout eingeben und [STRG]+[LEER] drücken, ersetzt der Editor dieses Kürzel durch System.out.println();.

001 public class HelloWorld { 002 public static void main(String[] args) { 003 System.out.println(); 004 } 005 }

Listing 3.3: HelloWorld nach dem Generieren der Konsolenausgabe

Vervollständigen Sie den Code, indem Sie zwischen den Klammern "Hello, world" einfügen:

001 public class HelloWorld { 002 public static void main(String[] args) { 003 System.out.println("Hello, world"); 004 } 005 }

Listing 3.4: HelloWorld

Und speichern Sie das Programm, indem Sie [STRG]+[S] drücken.

Um das Programm auszuführen, wählen Sie im Run-Menü »Run As...«, »Java Application« aus. In der unteren View tritt die Konsole in den Vordergrund und zeigt die Ausgabe:

Hello, world

Unter Eclipse braucht man Java-Klassen nicht explizit zu kompilieren, denn sobald eine Klasse nach einer Änderung gespeichert wird, kompiliert Eclipse diese und alle abhängigen Klassen automatisch im Hintergrund.

Tip

Wir haben nun mit relativ wenig Aufwand ein voll funktionsfähiges Programm erzeugt, das allerdings optisch noch nicht ganz unseren Erwartungen entspricht. Glücklicherweise besitzt der Editor einen Codeformatter, der Zeilen automatisch einrückt und Klammerungen korrigiert. Diesen ruft man mit dem Tastenkürzel [UMSCHALT]+[STRG]+[F] auf.

001 public class HelloWorld { 002 public static void main(String[] args) { 003 System.out.println("Hello, world"); 004 } 005 }

Listing 3.5: Formatierte HelloWorld-Implementation

Als Nächstes wollen wir Javadoc-Tooltips kennenlernen. Dokumentieren Sie dazu die main-Methode, indem Sie zwischen Zeile 1 und 2 des vorigen Listings eine weitere Zeile einfügen, /** hineinschreiben und [ENTER] drücken. Nun wird ein Methodenkommentar erzeugt:

001 public class HelloWorld { 002 /** 003 * 004 * @param args 005 */ 006 public static void main(String[] args) { 007 System.out.println("Hello, world"); 008 } 009 }

Listing 3.6: HelloWorld mit generierter main-Dokumentation

Dokumentieren Sie nun die main-Methode wie folgt:

001 public class HelloWorld { 002 /** 003 * Gibt "Hello, world" auf der Konsole aus. 004 * 005 * @param args Kommandozeilenparameter werden ignoriert 006 */ 007 public static void main(String[] args) { 008 System.out.println("Hello, world"); 009 } 010 }

Listing 3.7: HelloWorld mit main-Dokumentation

Wenn man nun mit der Maus auf das Wort main im Quelltext zeigt, öffnet sich ein Tooltip mit der zugehörigen Dokumentation.

Abbildung 3.3: Javadoc-Tooltip unter Eclipse

Das Gleiche funktioniert auch für Klassen- und Felddokumentationen und für alle im Klassenpfad eingelinkten Bibliotheken, insbesondere auch für alle Klassen des JDK. Dies gilt allerdings nur, sofern der Sourcecode zur Verfügung steht. Sie können das ausprobieren, indem Sie den Mauszeiger beispielsweise über die println-Methode oder die System-Klasse bewegen, um die passende Dokumentation aus dem JDK anzuzeigen. Dieses Feature ist praktisch und schnell und erspart den Medienbruch durch das Nachschlagen in einem externen Browser.

Gehen Sie nun mit dem Cursor in Zeile 008 des obigen Programms und drücken Sie gleichzeitig [STRG]+[ALT]+[CURSORRUNTER]. Halten Sie danach [STRG]+[ALT] gedrückt und drücken Sie mehrfach hintereinander [CURSORRUNTER]. Diese Tastenkombination kopiert jeweils die aktuelle Zeile und legt die neue Zeile darunter an. Das Programm sieht nun wie folgt aus:

001 public class HelloWorld { 002 /** 003 * Gibt "Hello, world" auf der Konsole aus. 004 * 005 * @param args Kommandozeilenparameter werden ignoriert 006 */ 007 public static void main(String[] args) { 008 System.out.println("Hello, world"); 009 System.out.println("Hello, world"); 010 System.out.println("Hello, world"); 011 System.out.println("Hello, world"); 012 System.out.println("Hello, world"); 013 } 014 }

Listing 3.8: Kopierte Zeilen

Führen Sie das Programm wie oben beschrieben aus oder drücken Sie in der Toolbar auf den Run-Button. Im Konsolenfenster erscheint folgende Ausgabe:

Hello, world
Hello, world
Hello, world
Hello, world
Hello, world

Gehen Sie nun in Zeile 009 des obigen Programms und drücken Sie [STRG]+[UMSCHALT]+[B]. Am linken Rand des Editors sehen Sie einen blauen Punkt, denn Sie haben soeben einen Breakpoint gesetzt, also eine Zeile markiert, an der das Programm während der Ausführung anhalten soll. Sie können einen Breakpoint auch mit der Maus setzen, indem Sie neben der betreffenden Zeile doppelklicken, also dort, wo der blaue Punkt steht.

Eclipse bietet einen integrierten Debugger zur Fehlersuche an. Er ist leistungsfähig, einfach zu bedienen und erlaubt es sogar, Programmcode im laufenden Programm zu ändern. Startet man die Anwendung im Debugger, bewirkt ein Breakpoint, dass der Debugger die Anwendung an dieser Stelle anhält und die Kontrolle an den Programmer zurückgibt. Dieser kann dann den Zustand der Variablen untersuchen oder zeilenweise weiter durch das Programm laufen.

Wir führen das Programm im Debugger aus, indem wir im Menü »Run«, »Debug As«, »Java Application« wählen. Der Debugger startet das Programm und hält die Ausführung an dem definierten Breakpoint an. Eclipse fragt nun, ob es in die Debug-Perspektive wechseln soll, was wir mit »Yes« beantworten. Rechts oben in der Toolbar sind nun zwei Togglebuttons »Debug« und »Java« zu sehen. Um später in die Java-Ansicht zurückzukehren, drücken Sie auf den Java-Togglebutton. Zunächst bleiben wir aber in der Debug-Ansicht.

Abbildung 3.4: Eclipse IDE in der Debug-Perspektive

Man kann nun leicht erkennen, dass der Debugger an einem Breakpoint stehen geblieben ist:

• In der oberen View sehen Sie den Stacktrace des unterbrochenen Threads. Er zeigt hervorgehoben HelloWorld.main(String[]) line: 9.
• In der mittleren View, also im Editor, ist Zeile 009 durch eine transparente Hintergrundfarbe hervorgehoben.
• In der Konsole sehen wir bislang nur eine Ausgabezeile Hello, world.

Bitte beachten Sie, dass Zeile 009, also die Zeile, in der wir den Breakpoint gesetzt haben, noch nicht ausgeführt wurde. Drücken Sie einfach [F6], um die nächste Zeile auszuführen und eine weitere »Hello, world«-Zeile auf der Konsole auszugeben. Wiederholen Sie diesen Schritt, bis das Programm vollständig abgearbeitet wurde.

Wir wollen es hier bei dieser kleinen Einführung bewenden lassen. Weitere Informationen finden sich in der Dokumentation zu Eclipse selbst oder in einem der zahlreichen Artikel und Dokumente, die frei im Internet verfügbar sind. Daneben gibt es eine Reihe auch deutschsprachiger Bücher, die sich Eclipse widmen und diese Entwicklungsumgebung mit all ihren Facetten viel umfassender behandeln, als wir das hier können.