$>
you're reading...
Tutorial

Die Eclipse-IDE – Ein Tutorial für Erstbenutzer


 

Was ist Eclipse?

Eclipse ist eine komfortable und mächtige integrierte Programmierumgebung, die ursprünglich für Programmiersprache Java entwickelt wurde, mittlerweile aber, mittels Plug-ins, für praktisch alle gängigen Programmiersprachen (z. B.: C, C++, C#, Python, Perl & PHP) genutzt werden kann. Die Entwicklung von Java-Anwendungen ist aber nach wie vor der Hauptverwendungszweck von Eclipse.

Der Ursprung von Eclipse liegt bei IBM, die Eclipse gegen Ende der 90er Jahre als Nachfolger der proprietären, auf Smalltalk basierenden, Entwicklungsumgebung Visual Age entwickelt haben. Im Jahr 2001 hat IBM den Quellcode offen gelegt und Eclipse zu einem Open-Source Projekt gemacht. Seit 2004 wird die Entwicklung von Eclipse von der Eclipse Foundation, einer unabhängigen non-profit Organisation, gesteuert.

Eclipse ist nicht nur eine einfache Java-Entwicklungsumgebung, sondern ein komplettes Framework, dass auch die Entwicklung von Rich-Client-Anwendungen und serverbasierten Applikationen ermöglicht.

Für wen ist dieses Tutorial gedacht?

Wie der Titel schon sagt, richtet sich dieses Tutorial an Erstbenutzer, also an Leute die noch nie mit Eclipse, vielleicht sogar überhaupt noch nie mit einer integrierten Programmierumgebung (IDE), gearbeitet haben. Diesen Erstbenutzern soll das Tutorial bei ihren ersten Schritten helfen, die grundlegenden Funktionen von Eclipse erklären und ganz allgemein dabei helfen, sich schnell zurechtzufinden und zügig mit der Verwirklichung eigener Projekte zu beginnen.

Anmerkung: Da dieses Tutorial etwas ausführlicher als ursprünglich geplant wurde, kann ich nicht ausschließen das sich der eine oder andere Fehler eingeschlichen hat – solltet ihr welche finden, bitte eine PN an mich!

1 – Grundlegendes

1.1 – Eclipse herunterladen & installieren

Die Eclipse IDE ist für alle gängigen Betriebssysteme und, selbstverständlich, auch als 32-Bit und 64-Bit Version verfügbar. Derzeit (Stand Februar 2011) ist die Version 3.6.1 mit dem Namen Helios, die aktuelle Version von Eclipse. Turnusmäßig erscheinen die neuen Versionen von Eclipse im Juni eines Jahres, die Version 3.7 ist demzufolge für den Juni 2011 geplant und wird Indigo heißen. Seit Januar 2011 gibt es aber auch eine Vorabversion.

Damit Eclipse korrekt ausgeführt werden kann, müssen natürlich die Systemanforderungen erfüllt sein, bei den heutigen Rechnern sollte das kein Problem sein, aber der Vollständigkeit halber hier die Liste:

Java Version: mindestens Version 1.4.0, empfohlen 6 oder höher
Hauptspeicher: mindestens 518 MB, empfohlen 1 GB oder mehr
Festplattenplatz: mindestens 300 MB, empfohlen 1 GB oder mehr
Prozessor: mindestens 800 GHz, empfohlen 1, 5 GHz oder schneller

Um Eclipse herunterzuladen besucht man einfach diese Seite und sucht sich die passende Version aus:

http://www.eclipse.org/downloads/

Anmerkung: Auf der Seite kann man auch Eclipse Classic und die Eclipse Enterprise Edition (EE) herunterladen, die einige zusätzliche Funktionen enthalten, dieses einfache Tutorial behandelt aber nur die Basisversion.

Die heruntergeladene Archiv-Datei anschließend einfach in das gewünschte Verzeichnis entpacken und schon ist die Installation abgeschlossen!

Wichtig: Die Sprache, mit der man Anwendungen entwickeln will, muss gegebenenfalls natürlich vorher installiert werden. Wenn man beispielsweise Java-Anwendungen entwickeln will, muss man zuerst das Java Development Kit (JDK) installieren! Das JDK bekommt man z. B. von hier:

http://www.oracle.com/technetwork/ja…ads/index.html

 

1.2 – Eclipse wird zum ersten Mal gestartet

Wenn Eclipse das erste Mal gestartet wird, erscheint zuerst der Ladebildschirm, rechts unterhalb des Eclipse Schriftzugs, kann man den Namen der installierten Version, z. B. Helios, lesen. Nach einem Moment erscheint ein Fenster mit dem Workspace Launcher. Als Workspace bezeichnet Eclipse das Verzeichnis, in dem alle Projekte und Anwendungen die der Benutzer erstellt, gespeichert werden. Hat man sich für ein Verzeichnis entschieden und den Pfad korrekt eingegeben, empfiehlt es sich die Option Use this as the default and do not ask again zu markieren – da dieses Fenster sonst bei jedem Start erscheint und der Ladevorgang bis zur Bestätigung unterbrochen wird. Selbstverständlich ist es auch nach der Markierung der default-Option möglich, den Pfad zu ändern! Nachdem man den Pfad bestätigt hat und der Ladevorgang beendet wurde, landet man beim Begrüßungsbildschirm von Eclipse.

Der Begrüßungsbildschirm bietet uns diverse Optionen, so kann man sich einen generellen Überblick (Overview) über das Programm, die neuen Features der installierten Version (What’s New), einige Beispiele (Samples) oder diverse Tutorials anzeigen lassen. Bis auf die Tutorials ist eigentlich nichts davon besonders interessant, daher empfiehlt es sich den Begrüßungsbildschirm vorerst zu verlassen (Workbench) und sich mit Eclipse vertraut zu machen. Selbstverständlich kann man auch später jederzeit zum Begrüßungsbildschirm zurückkehren und sich beispielsweise die Tutorials ansehen, indem man einfach in der Menüleiste das Help-Menü öffnet und die Option Welcome auswählt.

 

1.3 – Das Hauptfenster (Workbench)

Nach Verlassen des Begrüßungsbildschirms landet man im Hauptfenster, der sogenannten Workbench, dem eigentlichen Arbeitsplatz von Eclipse. Das Hauptfenster setzt sich aus verschiedenen wichtigen Elementen zusammen, neben der Menüleiste des Hauptmenüs und der Hauptsymbolleiste (Toolbar) direkt darunter, sind die wichtigsten Elemente die Perspektiven (Perspectives), Ansichten (Views) und Editoren (Editors). Betrachten wir diese Elemente einmal näher:

Perspektiven (Perspectives)

Eine Perspektive ist in Eclipse ein Oberbegriff für eine Reihe zusammengehöriger Menüs, Ansichten und Editoren. Die Perspektive erleichtert das arbeiten an einem Projekt, da sie speziell für eine bestimmte Aufgabe, z. B. das schreiben von Java-Code, entworfen wurde. Selbstverständlich kann man die Anordnung der Fenster beliebig verändern, neue Ansichten öffnen und die Perspektive so dem eigenen Geschmack anpassen. Die Änderungen bleiben erhalten und wenn man an dem Projekt weiter arbeiten will, öffnet man einfach die entsprechende Perspektive und schon sind die individuellen Einstellungen wieder da. Um eine Perspektive zu öffnen, muss man lediglich in der Menüleiste das Window-Menü öffnen und die Option Open Perspective auswählen. In der daraufhin erscheinenden Liste wählt man die gewünschte Perspektive aus, sollte sie nicht angezeigt werden, kann man über die Option Other eine vollständige Liste der Perspektiven anzeigen lassen. Eclipse verfügt in jeder Variation über diverse vordefinierte Perspektiven, die durch Plug-ins beträchtlich erweitert werden können.

Ansichten (Views)

Eine Ansicht ist im Grunde ein Fenster, in dem die verschiedensten Informationen dargestellt werden können. Oft verfügt eine Ansicht über Navigationsmöglichkeiten, z. B. die Auflistung aller Dateien in einem Projekt. In der Regel besitzt eine Ansicht eine Titelleiste, in der neben dem Namen der Ansicht und dem Close-Symbol, auch eine eigene Symbolleiste (Toolbar) mit Symbolenenthalten ist. Um zu erfahren welche Funktionen die Symbole haben, braucht man nur den Mauszeiger darüber bewegen und das Erscheinen des Tooltipps abzuwarten. Es ist möglich mehrere Ansichten übereinander zustapeln, in der Titelleiste werden dann Registerkartenreiter mit den Namen der Ansichten angezeigt, durch einen Mausklick auf den entsprechenden Reiter, wird die Ansicht aktiviert. Es kann allerdings immer nur eine Ansicht aktiv sein. Um eine Ansicht zu öffnen, muss man lediglich in der Menüleiste das Window-Menü öffnen und die Option Show View auswählen. In der daraufhin erscheinenden Liste wählt man die gewünschte Ansicht aus, sollte sie nicht angezeigt werden, kann man mit der Option Other eine vollständige Liste der Ansichten anzeigen lassen.

Editoren (Editors)

Editoren sind Fenster, die das Herzstück von Eclipse ausmachen, den sie ermöglichen es den Inhalt von Dateien anzuzeigen, zu ändern und zu speichern. Es gibt einfache Texteditoren, mit denen man Textdateien erstellen, ändern und speichern kann – aber für eine Entwicklungsumgebung sind natürlich spezielle Editoren wichtiger, die über sprachspezifische Kenntnisse verfügen. Der Java-Editor „kennt“ beispielsweise die komplette Java-Syntax und kann daher schon bei der Eingabe von Java-Code Syntaxfehler markieren, oder – zur besseren Lesbarkeit – Schlüsselwörter, Anweisungen und Bezeichner farblich hervorheben (syntax highlightning) und den Code durch Einrückung strukturieren. Natürlich ist es möglich mehrere Editoren des gleichen Typs nebeneinander geöffnet zu haben, z. B. einen Editor für jede Klasse eines Java-Projekts. Um den Inhalt eines Editors, also die eigene Arbeit, zu speichern, öffnet man einfach in der Menüleiste das File-Menü und wählt die Option Save, alternativ kann man auch die Tastenkombination Strg+S drücken. Ein Sternchen in der Titelleiste eines Editors bedeutet, dass der Editor ungespeicherte Änderungen enthält.

Menüs (Menues)

In Eclipse gibt es zahlreiche unterschiedliche Menüs, das wichtigste Menü ist zweifellos die Menüleiste am oberen Rand des Hauptfensters (Workbench), dieses Menü nennt man auch Hauptmenü. Andere Menüs sind an bestimmte Elemente, z. B. Ansichten (Views), gebunden. Desweiteren gibt es zahlreiche Kontextmenüs, die geöffnet werden, indem man mit der rechten Maustaste auf ein bestimmtes Element im Hauptfenster klickt.

Symbolleisten (Toolbars)

In Eclipse gibt es zahlreiche unterschiedliche Symbolleisten, die wichtigste befindet sich direkt unter dem Hauptmenü und wird Hauptsymbolleiste genannt. Symbolleisten bestehen aus einer Reihe von Symbolen (Buttons), mit denen man häufig genutzte Aktionen ausführen kann. Wenn man mit dem Mauszeiger über einem Symbol verharrt, erscheint ein Tooltipp mit näheren Informationen. Selbstverständlich kann man die Reihenfolge der Symbole innerhalb einer Symbolleiste per drag & drop beliebig verändern. Für gewöhnlich befinden sich die Symbolleisten am oberen Rand des Fensters zu dem sie gehören.

 

1.4 – Allgemeines zur Steuerung

In Eclipse lassen sich die meisten Anweisungen auf unterschiedliche Arten erteilen, so kann man z. B. mit der Maus einen Menüpunkt auswählen, mit der Maus das entsprechende Symbol in einer Toolbar anklicken oder einfach die entsprechende Tastenkombination (Shortcut) über die Tastatur eingeben. Shortcuts stellen zweifellos die schnellste Methode zur Bedienung von Eclipse dar, sind aber auch so zahlreich, dass es gerade für Anfänger nicht ganz leicht ist, sich alle zu merken. Allerdings lohnt es sich in jeden Fall, sich die Shortcuts von besonders häufig benutzen Aktionen möglichst früh einzuprägen. Die meisten Shortcuts stehen in den Menüs rechts neben dem Namen der Aktion. Für gewöhnlich besteht ein Shortcut aus einer Kombination von zwei Tasten, die gleichzeitig gedrückt werden müssen – gelegentlich sind es auch einmal drei Tasten.

Ansichten und Editoren lassen sich übrigens beliebig umgruppieren, verschieben und stapeln – die einzige Einschränkung ist, dass Editoren in ihrem rechteckigen Bereich bleiben müssen und nicht mit Ansichten vermischt werden dürfen. Allerdings kann man Ansichten um Editoren herum gruppieren und sogar außerhalb des Hauptfenster platzieren. Um einen Editor oder eine Ansicht zu verschieben, muss man einfach mit der Maus auf die Titelleiste klicken und das Element an den gewünschten Ort ziehen. Wenn man ein Element mit der Maus verschiebt, verändert sich der Mauszeiger um anzuzeigen wo das Element platziert wird, wenn man es loslässt: Ein Linkspfeil bedeutet beispielsweise das Element wird links von dem Fenster unter dem Mauszeiger platziert, ein Pfeil nach oben bedeutet dementsprechend das Element wird oberhalb des Fenster unter dem Mauszeiger platziert.

Selbstverständlich kann man bei Ansichten und Editoren auch die Größe verändern, indem man den Mauszeiger über eine Kante bewegt und dann, sobald er sich in einen Doppelpfeil verwandelt, das Fenster auf die gewünschte Größe zieht. Manchmal möchte man sich auch auf ein einzelnes Element konzentrieren, z. B. auf einen Editor, dann kann man dieses Element ganz einfach durch einen Doppelklick auf die Titelleiste maximieren. Um das Element wieder auf die ursprüngliche Größe zu bringen, reicht ein weiterer Doppelklick auf die Titelleiste. Alternativ kann man auch die, für Fenster üblichen, Symbole zum Maximieren und Minimieren in der oberen rechten Ecke des Element-Fensters klicken.
Alle Änderungen und Einstellungen des Nutzers bleiben erhalten und werden genauso angezeigt, sobald Eclipse, bzw. die entsprechende Perspektive, das nächste Mal geöffnet wird.

 

2 – Es geht los: Von Projekten, Paketen, Klassen und Konsolen

Nachdem wir uns mit den Grundlagen vertraut gemacht haben, können wir nun zum eigentlichen Zweck einer integrierten Entwicklungsumgebung kommen: Dem Entwickeln von eigenen Programmen und Anwendungen. Der Einfachheit halber setzte ich voraus das eine Java-Anwendung geschrieben werden soll und das die Standard-Perspektive zur Java Entwicklung, Java (default), geöffnet wurde. Diese Perspektive besteht aus der Ansicht des Projekt-Explorers auf der linken Seite, einem Java-Editor rechts daneben und einer Konsole unterhalb des Editors.

Hinweis: Wenn die Perspektive erstmals geöffnet wird und es noch keine Java-Projekte, Pakete und Klassen gibt, fehlen einige dieser Elemente möglicherweise noch.

2.1 – Ein Projekt (Project) anlegen

Ein Projekt ist in Eclipse eigentlich nur ein Verzeichnis, in dem sämtliche Ressourcen, die zu einem bestimmten Programm gehören, liegen – also der Quellcode des Programms, aber auch Icons und Images die eingebunden werden sollen oder sonstige Dateien die für die Ausführung des Programms benötigt werden.

Um ein Projekt anzulegen, öffnet man im Hauptmenü das File-Menü, wählt erst die Option New (alternativ: Shift+Alt+N) und dann Java Project. Daraufhin erscheint ein Dialogfenster in dem man den Namen des Projekts eingeben und unter Location den Pfad des Verzeichnisses eingeben kann. Ist die Option Use default location markiert, wird automatisch der Pfad zum Workspace eingetragen. Ich würde diese Option auch empfehlen – wozu hat man sonst ein solches Verzeichnis?

Sobald man den Namen eingegeben hat und mit dem Pfad zufrieden ist, kann man das Projekt mit einem Klick auf Finish anlegen oder einfach <Enter> drücken – es gibt hier zwar noch weitere Einstellungsmöglichkeiten, doch die brauchen uns vorerst nicht zu interessieren. Sobald das Projekt über Finish angelegt wurde, erscheint es links in der Project Explorer View. Wenn man den Workspace als Zielverzeichnis ausgewählt hat, erscheint in diesem Verzeichnis jetzt ein neuer Ordner, der den gewählten Projektnamen, als Namen hat. Alle Dateien, z. B. Klassen, die mittels Eclipse entwickelt werden und zu diesem Projekt gehören, werden in diesem Ordner gespeichert. Sollten für das Projekt Bilder oder Textdateien nötig sein, kann man diese auch einfach in diesen Ordner kopieren. Ein Projekt dient also hauptsächlich der Ordnung, indem es einen Ordner bereitstellt, der alles was zusammengehört auch an einem Ort zusammenfasst.

Der Ordner ist übrigens nicht leer, bei einem Java-Projekt enthält er bereits zwei Unterordner: Das Verzeichnis bin und das Verzeichnis src. In dem Verzeichnis src wird der Quellcode jeder Datei, die man mit dem Java-Editor erstellt, gespeichert. Das Verzeichnis bin enthält den Bytecode dieser Dateien, sobald man sie speichert und so kompiliert. Zu Beginn sind diese Ordner natürlich leer.

2.2 – Ein Paket (Package) anlegen

Ein Java-Paket dient dazu Klassen eine Projekts in Gruppen zusammenzufassen. Es ist durchaus möglich Klassen ohne ein Paket zu erstellen, doch es ist definitiv besser sich diese Praxis von Anfang an anzugewöhnen – bei großen Projekten, mit einer Vielzahl von Klassen kann man so Klassen, die in einer engen Beziehung zueinander stehen, in entsprechenden Namensräumen gruppieren.

Um ein Paket anzulegen, kann man entweder im Project Explorer mit der rechten Maustaste auf das gerade angelegt Projekt klicken und im Kontextmenü die Option New und dann Package auswählen, oder man öffnet das File Menü im Hauptmenü und wählt dann nacheinander die Optionen New und Package. Daraufhin erscheint ein Dialogfenster mit zwei Spalten, in der oberen Spalte (Source folder) steht der Pfad zu den Quellcode-Dateien des Projekts, also: Projektname/src.
In der Spalte darunter kann man jetzt einfach den Namen des Pakets eingeben, z. B. projekt.test und mit Finish bestätigen oder einfach <Enter> drücken.

Im Unterverzeichnis src des Projektordners erscheint nun ein Unterverzeichnis mit dem Paketnamen – hier legt Eclipse alle Quellcode-Dateien ab, die zu dem Projekt und zu diesem Paket gehören. Bei einem größeren Projekt könnte man z. B. in dem Paket main die Klassen ablegen, die alle grundlegenden Funktionalitäten der Anwendung implementieren und in einem Paket gui alle Klassen für die grafische Oberfläche ablegen. Pakete dienen also vor allem der besseren Übersicht, bzw. der Ordnung. Dem Programmierer dabei zu helfen die Ressourcen für seine Projekte effizient und übersichtlich zu verwalten, ist eine wichtige Aufgabe einer IDE.

2. 3 – Eine Klasse anlegen

Jetzt sind wir also endlich soweit und können mit dem entwickeln eigener Anwendungen beginnen, zuerst müssen wir aber natürlich noch eine Klasse anlegen.

Um eine Klasse (Class) anzulegen, klickt man einfach mit der rechten Maustaste auf das gerade angelegte Paket und wählt im Kontextmenü die Option New und dann Class – alternativ kann man auch hier natürlich über das File-Menü im Hauptmenü eine neue Klasse anlegen oder einfach auf das Symbol New Java Class in der Hauptsymbolleiste klicken. Daraufhin erscheint ein Dialogmenü, dass sowohl den Pfad unseres Source folders, als auch den Namen unseres Pakets enthält. In der Spalte Name geben wir jetzt einfach den Namen unserer Klasse, also z. B. HelloWorld, ein und beachten dabei natürlich die Java-Namenskonvention.

Das Dialogfenster enthält noch weitere Optionen, die uns zunächst aber nicht interessieren müssen. Wenn man jedoch unterhalb der Frage Which method stubs do you like to create? die Option public static void main(String[]args) markiert, nimmt uns Eclipse freundlicherweise etwas Tipparbeit ab. Wie üblich legen wir die Klasse durch einen Klick auf Finish oder über die Taste <Enter> an. Wie wir in der Project Explorer View sehen können, steht dort jetzt unter Projektname/src/Paketname eine Datei namens HelloWorld.java. Viel spannender ist aber der Java-Editor, der sich geöffnet haben sollte!

2.4 – Code eingeben & Ausführen

In der Titelleiste des Java-Editors steht der Name der Klasse, die wir gerade angelegt haben – wenn man später an mehreren Klassen arbeitet, kann man jede Klasse in einen eigenen Java-Editor öffnen und die gewünschte Klasse mit einem Klick auf ihren Namen, im Registerkartenreiter der Titelleiste, in den Vordergrund holen.

Was natürlich sofort auffällt ist die Tatsache, dass Eclipse schon Code in dem Editor unserer Klasse generiert hat: Ganz oben steht unser Paketname, darunter befindet sich eine gültige Klassendefinition, also eine mittels den Schlüsselwörtern public class und unseren Namen angelegte Klasse, mit den zugehörigen öffnenden und schließenden geschweiften Klammern. Wenn man die entsprechende Option aktiviert hat, befindet sich in der Klasse auch schon eine gültige main-Methode. Im Methodenrumpf, also zwischen den geschweiften Klammern der main Methode, befindet sich ein einzeiliger TODO-Kommentar. Wann immer Eclipse Code generiert, fügt es solche TODO-Kommentare hinzu, um dem Programmierer zu zeigen welche Stellen noch bearbeitet werden müssen. Es ist möglich sich über die Task View alle TODO-Kommentare anzeigen zulassen. Die Task View ruft man wie gewohnt über das Window-Menü und die Optionen Show View und dann Tasks im Hauptmenü auf. Sobald Eclipse Code generiert und gespeichert hat, erscheint die Bytecode-Datei der entsprechenden Klasse im bin Verzeichnis des Projektordners – wobei es natürlich auch im bin Verzeichnis den Unterorder für das Paket gibt. In unserem Beispiel findet sich dort also jetzt die Datei HelloWorld.class.

Ebenfalls fällt auf, dass der Java-Editor den Code verschiedenfarbig darstellt – dieses Feature nennt man Syntaxhervorhebung (syntax highlighting) und es dient natürlich dazu den Code lesbarer und übersichtlicher zu gestalten. Dank der Syntaxhervorhebung kann man Schlüsselwörter, Anweisungen und Bezeichner auf den ersten Blick erkennen. Zusammen mit der automatischen Formatierung, bzw. Einrückung, liefert der Editor damit mächtige Werkzeuge um Code schnell, effektiv und übersichtlich zu entwickeln.

Wenn man jetzt den TODO-Kommentar löscht und z. B, durch ein simples System.out.println(„Hallo Welt!“); ersetzt, haben wir unsere erste Anwendung mit Eclipse entwickelt. Wenn man sich dabei vertippt, erkennt Eclipse den Syntaxfehler sofort und unterstreicht die entsprechende Stelle mit einer gewellten, roten Linie – ganz genau wie ein simples Textverarbeitungsprogramm. Zusätzlich erscheint am linken Rand des Editors eine Markierung, die anzeigt das sich in dieser Zeile ein Fehler befindet. Wenn man diese Markierung anklickt oder den Mauszeiger einen Moment über den fehlerhaften und unterstrichenen Code schweben lässt, erscheint ein Pop-up Menü mit Korrekturvorschlägen. Wenn einer der Vorschläge das Problem behebt, kann man einfach auf diesen Vorschlag klicken und er wird automatisch umgesetzt. Nehmen wir an, wir haben anstatt System.out.println() versehentlich Systema.out.println() geschrieben – dann wird das Wort Systema rot unterstrichen. Wenn wir jetzt den Mauszeiger darüber bewegen, erscheint ein Pop-up, dass uns in der ersten Zeile Informationen über den Fehler liefert – in diesem Fall: Systema cannot be resolved. Darunter stehen zahlreiche Korrekturvorschläge, einer davon lautet: Change to ‚System‘ (Java.lang). Diesen Vorschlag klicken wir an und schon hat Eclipse unseren Fehler korrigiert!
Da unser kleines Programm jetzt fehlerfrei ist, können wir es speichern und ausführen. Speichern kann man die Anwendung über das File-Menü im Hauptmenü, durch einen Klick auf das Disketten-Symbol oder durch die Tastenkombination Strg+S. Beim Speichern wird der Code kompiliert und kann dann ausgeführt werden. Wenn man das Speichern vergessen hat, bevor man auf Run klickt, erscheint jedoch ein Fenster in dem wir den entsprechenden Code speichern können. Editoren die ungespeicherte Inhalte enthalten, werden in der Titelleiste mit einem Sternchen markiert. Bei jedem Speichervorgang wird das Programm kompiliert und die Bytecode-Datei im bin Verzeichnis aktualisiert.

Ausführen lassen können wir den Code über das Run Menü im Hauptmenü, durch einen Klick auf das Run Symbol oder durch die Tastenkombination Strg+F11. Einen Moment später erscheint die Ausgabe Hallo Welt! in der Konsole. Anwendungen die wir in Eclipse erstellen und ausführen, werden immer in einer Konsole ausgeführt. In der Konsole erscheinen die Ausgaben der Anwendung und wenn wir einen Dialog oder ein Menü in unseren Code eingebaut hätten, könnten wir in der Konsole unsere Eingaben vornehmen. Wenn wir die Anwendung vorzeitig abbrechen wollen oder wir z. B. versehentlich eine Endlosschleife fabriziert haben, können wir es mit einem Klick auf das Terminate-Symbol in der Symbolleiste der Konsole sofort anhalten, alternativ kann man Terminate auch durch das Run-Menü im Hauptmenü erreichen oder einfach die Tastenkombination Strg+F2 drücken. Jetzt sind wir also so weit, dass wir in Eclipse eigene Projekte, Pakete und Klassen anlegen und editieren können, wobei sich das Programmieren komfortabel gestaltet, weil wir uns auf Features wie Syntaxerkennung und Syntaxhervorhebung stützen können – doch Eclipse hat noch mehr Unterstützung für Programmierer zu bieten!

 

3 – Der beste Freund des Programmierers: Der Debugger

Jeder Programmierer weiß: Es gibt keinen fehlerfreien Code. Je umfangreicher und komplexer der Code einer Anwendung wird, desto mehr Fehler oder Bugs schleichen sich ein. Und längst nicht alle Fehler sind einfache Tippfehler, die schon während der Eingabe von der Syntaxerkennung angemahnt werden, sondern es gibt Fehler, die so unauffällig sind, dass sich der Code anstandslos kompilieren lässt und die erst zur Laufzeit einer Anwendung auffallen. Beispiele für solche Fehler können z. B, Endlosschleifen sein, Verletzungen des gültigen Wertbereichs der Variablen eines bestimmten Datentyps oder auch ein ungültiger Zugriff auf den Index eines Arrays – tatsächlich gibt es so viele verschiedene Möglichkeiten, das die Fehlersuche einen nicht unbeträchtlichen Teil der Entwicklungszeit eines komplexen Projekts einnimmt. Aus diesem Grund stellen IDEs dem Entwickler mächtige Werkzeuge zur Fehlersuche zur Verfügung: Die sogenannten Debugger.

Im Grunde ähnelt das Debuggen der normalen Ausführung einer Anwendung, nur das man die Anwendung z. B. Zeile für Zeile durchgehen kann oder das man im Code sogenannte Breakpoints setzen kann, an denen der Debugger die Ausführung stoppt, und man sich dann die entsprechende Stelle in der speziellen Debug Perspective ansehen kann. Tatsächlich ist der Eclipse Debugger so ein mächtiges Werkzeug, dass es den Rahmen dieses kleinen Tutorials sprengen würde, auf alle Einzelheiten und Möglichkeiten des Debugger einzugehen! Daher beschränke ich mich auf die grundlegende Bedienung des Debuggers:

3.1 – Eine Anwendung unter Aufsicht des Debuggers ausführen

Das Starten einer Anwendung unter Aufsicht des Debuggers, funktioniert ganz ähnlich wie das normale Ausführen: Man kann entweder im Project Explorer mit der rechten Maus auf die entsprechende Klasse klicken und im Kontextmenü den Punkt Debug as wählen, im Run-Menü des Hauptmenüs die Option Debug wählen, auf das Debug-Symbol in der Hauptsymbolleiste klicken oder man drückt einfach die Taste F11.

Wenn wir unsere HelloWorld Klasse mit F11 ausführen lassen, erscheint die gewohnte Ausgabe Hallo Welt! In der Konsole und das Programm wird beendet – der Code enthält eben keinen Fehler. Selbstverständlich ist es auch im Debugger jederzeit möglich die Ausführung mit Terminate abzubrechen – einfach auf das Terminate-Symbol in der Symbolleiste der Konsole klicken, im Run- Menü des Hauptmenüs die Option Terminate wählen oder die Tastenkombination Srtg+F2 drücken. Es ist auch möglich eine Anwendung Zeile für Zeile ausführen zu lassen, dazu gibt es zwei Möglichkeiten: Step Into und Step Over. Der Unterschied liegt darin wie Zeilen behandelt werden, die einen Methodenaufruf beinhalten: Mit Step Into landet man in der ersten Zeile der Methode, bei Step Over wird die Methode ausgeführt und man landet in der ersten Zeile nach der Abarbeitung der Methode. Beide Möglichkeiten erreicht man über das Run-Menü im Hauptmenü oder über die Tasten F5 für Step Into und F6 für Step Over.

3.2 – Breakpoints setzen

Um die Ausführung der Anwendung an einer bestimmten Stelle zu stoppen und sich den betreffenden Code in der Debug Perspective anzusehen, müssen wir Breakpoints setzen. Breakpoints lassen sich einfach setzen, indem man am linken Rand des Editors mit der rechten Maustaste auf die Höhe der betreffenden Zeile klickt und im Kontextmenü die Option Toggle Breakpoint wählt. Gesetzte Breakpoints bleiben übrigens auch erhalten, wenn sich die Zeile durch Änderungen im Code verschiebt, praktischerweise „merkt“ sich der Breakpoint seine Zeile und wandert entsprechend mit. Wenn wir jetzt einen Breakpoint in der Zeile mit der Print-Anweisung setzen und die Anwendung mit F11 ausführen, stoppt der Debugger an dieser Stelle und fragt uns ob wir die Debug Perspective öffnen wollen. Zum Entfernen eines Breakpoints klickt man einfach mit der rechten Maustaste auf die Markierung und wählt im Kontextmenü die Option Toggle Breakpoint und der Breakpoint verschwindet.

Im Kontextmenü gibt es auch die Option Disable Breakpoint, diese Option lässt die Ausführung an dieser Stelle nicht mehr unterbrechen, behält aber eine verblasste Markierung als Gedächtnisstütze an dieser Stelle bei. Wenn man die Ausführung der Anwendung fortsetzen will, klickt man einfach auf das Resume-Symbol in der Symbolleiste der Debug View, wählt im Run-Menü des Hauptmenüs die Option Resume oder drückt einfach die Taste F8. Die Anwendung läuft dann bis zum nächsten Breakpoint, bis zum nächsten gefundenen Fehler oder bis zum regulären Ende durch. Die Breakpoint View der Debug Perspective enthält eine Liste aller gesetzten Breakpoints und bietet darüberhinaus eine komfortable Möglichkeiten Breakpoints zu setzen, zu löschen und zu verwalten.

3.3 – Die Debug Perspective

Die Debug Perspective öffnet alle Views die nötig sind, um das Verhalten einer Anwendung zur Laufzeit zu analysieren, auftretende Probleme und Fehler zu identifizieren und letztendlich zu korrigieren. Es ist nicht zwingend erforderlich für das Debuggen eine eigene Perspektive zu verwenden (alle Views können ja jederzeit auch über das Window-Menü im Hauptmenü geöffnet werden!), aber es empfiehlt sich, meiner Meinung nach, da zum Debuggen zahlreiche Views gehören, die zum normalen Programmieren nicht benötigt werden.

Die wichtigste Ansicht ist natürlich die Debug View, die alle ausgeführten Anwendungen auflistet und über eine Toolbar mit nützlichen Aktionen wie Terminate, Resume, Step Into und Step Over verfügt. Über Step Filters kann man hier auch Filter einstellen, die regeln bei welchen Stellen die Ausführung unterbrochen werden soll.
Darüberhinaus gibt es die Variables View, die alle sichtbaren Werte von Variablen, Parametern und Arrays und ihre Änderungen zur Laufzeit anzeigt. Natürlich ist es auch möglich selbst Änderungen vorzunehmen.

Es ist sicher sinnvoll sich intensiv mit dem Debugger und den diversen Views der Debug Perspective zu beschäftigen, denn der Debugger ist, wie gesagt, ein extrem mächtiges Werkzeug von Eclipse. Für den Anfang sollte dieser kleine Überblick über den Debugger jedoch reichen und auch durch experimentieren, also Learning by doing, wird man viel nützliches lernen können. Wenn man Eclipse jedoch für sehr komplexe Projekte einsetzen will, wird man nicht umhin kommen, sich gründlicher in diese Thematik einzulesen.

 

4 – Was man sonst noch dringend können sollte

Zum Schluss noch ein paar Anleitungen zu simplen, aber wichtigen oder einfach nur nützlichen Features von Eclipse…

4. 1 – Plug-ins installieren

Eine der Stärken von Eclipse liegt darin, dass es zahlreiche Plug-ins für die IDE gibt. Man kann Eclipse mittels Plug-ins die Unterstützung neuer Programmiersprachen beibringen oder auch deutsche Sprachpakete für Eclipse installieren (davon würde ich allerdings abraten!).
Um ein Plug-in zu installieren, wählt man einfach im Help-Menü des Hauptmenüs die Option Install new Software und gibt dann über Add die URL der Seite an, die das gewünschte Plug-in bereitstellt. Kurz darauf erscheint ein Explorer mit allen Plug-ins, die diese Seite bereit hält. Man wählt jetzt einfach das entsprechende Plug-in aus und bestätigt mit Next. Dann bestätigt man gegebenenfalls noch die Lizenzvereinbarung und klickt auf Finish. Über einen Statusbalken kann man dann die Installation verfolgen und wird zum Schluß noch aufgefordert Eclipse neu zu starten – wir kommen der Aufforderung nach und schon beim nächsten Start ist das Plug-in aktiv und Eclipse um ein Feature reicher!

Hinweis: Es ist auch möglich Plug-ins als Zip-Archive herunterzuladen und direkt ins Unterverzeichnis plugins von Eclipse zu entpacken, doch diese Methode ist veraltet und so installierte Erweiterungen lassen sich nicht automatisch aktualisieren und sind möglicherweise schwerer zu entfernen!

4. 2 – Plug-ins deinstallieren

Um ein mit dem Update-Manager installiertes Plug-in zu deinstallieren, wählt man einfach im Help-Menüdes Hauptmenüs die Option About Eclipse und klickt in dem sich öffnenden Fenster auf Installation Details. Es öffnet sich ein neues Fenster, das unter der Registerkarte Installed Software alle installierten Erweiterungen anzeigt. Hier wählt man einfach das unerwünschte Plug-in aus, klickt dann auf Uninstall und bestätigt mit Finish. Wenn keine Probleme wegen Abhängigkeiten auftreten, wird das Plug-in daraufhin gelöscht und nach dem obligatorischen Neustart, ist die unerwünschte Erweiterung Geschichte.

Hinweis: Unter Installed Software werden i. d. R. Nur Plug-ins angezeigt, die via Update Manager installiert wurden – um manuell installierte Erweiterungen zu löschen, muss man den entsprechenden Ordner im dropins Verzeichnis von Eclipse löschen!

4. 3 – Eclipse aktualisieren

Um Eclipse, einschließlich der via Update Manager installierten Plug-ins, aktuell zu halten, genügt es im Help-Menü des Hauptmenüs die Option Check for Updates auszuwählen, gefundene Updates werden dann automatisch installiert. Das sollte man gelegentlich auch tun, um zu sehen ob es neue Updates gibt. Wenn alles aktuell ist, meldet Eclipse: There is nothing to update.

4. 4 – Eclipse neu installieren

Wenn man eine neue Version von Eclipse, beispielsweise Indigo, installieren will, empfiehlt sich eine komplette Neuinstallation. Dazu löscht man den alten Eclipse Ordner (man kann ihn natürlich auch einfach umbenennen!), lädt das neue Eclipse-Archiv herunter und entpackt es. Natürlich kann man den alten Workspace problemlos in die neue Version einbinden (also nicht versehentlich mitlöschen!). Installierte Plug-ins müssen natürlich ebenfalls neu installiert werden.

http://marketplace.eclipse.org/

http://www.eclipse.org/forums/

http://wiki.eclipse.org/Main_Page

PDF Download Eclipse Keyboard Shortcuts

PDF Download Eclipse Keyboard Shortcuts 3.1 Emacs configuration

sem

Creative Commons Lizenzvertrag
Diese(s) Werk bzw. Inhalt von sem steht unter einer Creative Commons Namensnennung-Weitergabe unter gleichen Bedingungen 3.0 Unported Lizenz.
Beruht auf einem Inhalt unter www.hackerboard.de.

Diskussionen

Es gibt noch keine Kommentare.

Schreibe einen Kommentar

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

Member of The Internet Defense League

Kalender

Februar 2011
M D M D F S S
« Jan   Mrz »
 123456
78910111213
14151617181920
21222324252627
28  

Kategorien

Archiv

Legal Guide For Bloggers

Bloggers' Rights at EFF

Interessantes

Link Anonymizer

Independent Tests of Antiv-Virus Software

BSD Aktuell

Hacker News

Blog Stats

  • 260,017 hits

Haftungsausschluss

disclaimer

%d Bloggern gefällt das: