Nutzungshinweise für BlueJ

Transkript

1 Thema: Nutzung der Entwicklungsumgebung BlueJ Autoren: Prof. Dr. Stephan Kleuker Version / Datum: 1.0 / Empfänger: Teilnehmer der Lehrveranstaltungen im Bereich Programmierung 1 Vorbemerkungen Installation von Java Installation von BlueJ Erste Nutzung von BlueJ Anlegen eines Projektes Laden eines existierenden Projekts Erstellung einer ersten Klasse Kompilierung einer Klasse Erstellung eines Objektes einer Klasse Ausführung von Exemplarmethoden Genaue Analyse eines Objekts Nutzung des Code Pad Weitere Nutzung von Objekten Arbeiten mit mehreren Klassen in BlueJ Laden externer Klassen Nutzung der Eingabeklasse Ein einfaches Programm mit Nutzung einer Sammlung Nutzung des Debuggers Testen Erzeugen einer Testklasse Ausführung von Tests Nutzung eines alternativen Editors (Eclipse) Bearbeitung von BlueJ-Code aus Eclipse heraus Eclipse referenziert BlueJ-Dateien Nutzung von nicht in BlueJ erstellten Projekten Installation des Screenshot-Werkzeugs Faststone Capture Herunterladen und Installieren Portable Alternative Seite 1 von 136

2 10.3 Erste Schritte in der Nutzung Nutzung des Screenshot-Werkzeugs Shotty Starten Konfigurieren Nutzung Seite 2 von 136

3 1 Vorbemerkungen Diese Anleitung fasst einige Tipps und Tricks zum Umgang mit BlueJ in den einführenden Lehrveranstaltungen zur Programmierung zusammen. Dieser Text ist nicht als vollständiges Manual anzusehen. In der Lehrveranstaltung, insbesondere in den Praktika wird für konkrete Aufgaben auf einzelne Kapitel dieses Texts verwiesen. BlueJ ist ein recht mächtiges Werkzeug, das allerdings dann sehr einfach zu bedienen ist, wenn man sich an die typischen Arbeitsabläufe hält, die fast kein Detailwissen über BlueJ erfordern. BlueJ ist deshalb sehr gut für Anfänger geeignet. Jeder Nutzer ist aufgefordert, sich selbst intensiver mit BlueJ zu beschäftigen, da man dann einige Arbeitsschritte noch vereinfachen kann. Diese Hinweise fokussieren auf die Microsoft-Version, fast alle Informationen können aber auch auf die anderen Versionen übertragen werden. Konkret ist nur zu beachten, dass Java bis einschließlich der Version 6 für Apple OS X ausschließlich von den Web-Seiten von Apple erhältlich ist. Damit BlueJ funktioniert, ist vorher Java, genauer ein JDK ab der Version 6, zu installieren. Bei der Installation ist u. a. die korrekte Setzung der Pfadvariablen (PATH) zu beachten, in die das bin-verzeichnis der Java-Installation einzutragen ist. Im Folgenden bezieht sich die textuelle Beschreibung immer auf das nachfolgende Bild. Bei einzelnen Bildern können nach dem Bild noch Kommentare ergänzt werden. Man beachte in den Bildern die Position des Mauszeigers, der, wenn existent, auf die auszuführende Aktion hinweist. Generell benötigen Anfänger sehr wenige Befehle, um sinnvoll mit BlueJ arbeiten zu können. Bei Zeit und Interesse ist jeder aufgefordert, sich z. B. durch das Lesen der Tutorials in den Help-Files intensiver zu informieren. Im Text steht häufiger ein z. B., um anzudeuten, dass es verschiedene Wege gibt, die gleiche Aktion durchzuführen. Diese Hinweise enthalten Beschreibungen, wie man das Werkzeug nutzt. Generell sollte man sich immer fragen, warum man was macht. Diese Fragen werden getrennt in den Vorlesungen zur Programmierung behandelt. Dieser Text lebt weiterhin von Kommentaren der Nutzer; wenn Sie Anmerkungen haben, sei auch nur ein einfacher Rechtschreipfehler, schicken Sie diese an einen der Autoren. Weitere Informationen zu BlueJ können natürlich von den zugehörigen Web-Seiten geladen werden. Hilfreich ist dabei auch die Seite wobei sich die Informationen meist auf ältere Versionen von BlueJ beziehen, was aber (im Wesentlichen) kein Problem ist. Am Anfang sind das BlueJ Tutorial und das BlueJ Reference Manual mit recht ähnlichen Inhalten sehr hilfreich. Seite 3 von 136

4 Weitere Informationen kann man natürlich ergoogeln, dabei wird die Suche nach BlueJ zusammen mit filetype:pdf vorgeschlagen, wodurch PDF-Dokumente mit BlueJ im Inhalt gefunden werden. Man findet dabei einige mit diesen Hinweisen vergleichbare Dokumente, die ebenfalls zum Selbststudium geprüft werden können. Natürlich sind einige Besonderheiten dieses Dokuments, wie die absichtliche Wiederholung einiger Schritte ohne die Nutzung nerviger Querverweise und das Eingehen auf Probleme und Lösungsmöglichkeiten, in anderen Dokumenten nicht (oder nur teilweise) enthalten. An den erhaltenen Suchergebnissen kann man auch die hohe Verbreitung von BlueJ an Universitäten, Hochschulen und sonstigen Bildungseinrichtungen gut erkennen. Seite 4 von 136

5 Googelt man mit filetype:ppt kann man weiteres Lehrmaterial finden. Abschließend sei angemerkt, dass in diesen Hinweisen die männliche Form von Substantiven vereinfachend und kompakter gewählt wird, auch wenn natürlich immer auch die weibliche Form von Substantiven mit gemeint ist. Seite 5 von 136

6 2 Installation von Java Hinweis: Gerade nach dem Aufkauf von Sun durch Oracle haben sich die Seitenstrukturen häufiger geändert, so dass man immer auf kleine Änderungen im Download-Prozess vorbereitet sein sollte. Java wird direkt von der Sun-Seite heruntergeladen, dabei benötigt man das Development Kit (JDK), auch Java for Developers genannt, und nicht nur die Runtime-Version. Statt über den Link ist der Zugang auch noch über möglich. Die genaue Java-Version, sogar ob es Version 6.x oder Version 7 ist, spielt keine Rolle. Seite 6 von 136

7 Wichtig ist nur, dass ein JDK, ein Java Development Kit, heruntergeladen wird, da nur damit die eigene Entwicklung möglich ist. Mit einer JRE, einer Java Runtime Enviroment, können nur fertige Java-Programme ausgeführt werden. Seite 7 von 136

8 Zunächst liest man die Lizenbedingungen (Link im mittleren Kasten) und klickt dann den Kreis links neben Accept License Agreement, um die Annahme der Lizenz zu bestätigen. Seite 8 von 136

9 Man wählt das Betriebssystem (hier die Beschreibung für Windows) und klickt den Link unter Download. Bei der folgenden Meldung hat man vergessen, oben die Lizenzbedingungen zu bestätigen. Seite 9 von 136

10 Dann kann der Download stattfinden. Der Download dauert etwas. Weiterhin ist es sinnvoll, die Dokumentation zu Java, JavaDoc, weiter unten von der Auswahlseite herunterzuladen, was hier nicht weiter betrachtet wird. Die Installation von Java wird durch einen Doppelklick auf die heruntergeladene Datei gestartet. Seite 10 von 136

11 Nach einer eventuell notwendigen Bestätigung, dass die Installation durchgeführt werden soll, kann der Wizard gestartet werden. Die Default-Einstellungen können übernommen werden, man sollte sich den Installationspfad merken. Seite 11 von 136

12 Die Installation benötigt etwas Zeit. Eventuell wird man aufgefordert, den Installationsort für die JRE anzugeben. Der Vorschlag wird hier übernommen. Seite 12 von 136

13 Sollten noch Programme offen sein, die eine vorherige Java-Installation nutzen, sind diese zu schließen, um dann die Installation fortzusetzen. Danach wird die Java-Installation abgeschlossen und man erhält die Möglichkeit sich als Nutzer zu registrieren, was allerdings nicht notwendig ist. Seite 13 von 136

14 Zum Abschluss sollte noch die Systemvariable JAVA_HOME auf das Installationsverzeichnis gesetzt werden. Ein Weg dazu sieht wie folgt aus. Man wählt die Systemsteuerung im Start-Menü. Etwas abhängig von den bisher gemachten Betriebssystemeinstellungen kann sich folgende Seite öffnen, bei der auf System und Sicherheit geklickt wird. Falls die Seite anders aussehen sollte, muss man bei der Möglichkeit System anzuklicken weiterlesen. Seite 14 von 136

15 Nun wird der Link System geklickt. Sollte die Seite nach der Auswahl der Systemsteuerung wie folgt aussehen, wird ein Doppelklick auf System durchgeführt.. Seite 15 von 136

16 Hier wählt man den Punkt Erweiterte Systemeinstellungen mit einem einfachen Klick aus. Man nutzt den Reiter Erweitert und klickt unten auf Umgebungsvariablen. Seite 16 von 136

17 Administratoren des Systems nutzen den Knopf Neu... unter Systemvariablen, andere Nutzer den Knopf unter Benutzervariablen. Seite 17 von 136

18 Hier trägt man den Variablennamen sowie den Pfad zu installierten JDK ein und bestätigt die neue Variable mit OK. Man beachte, dass wahrscheinlich eine aktuellere Variante des JDK installiert wurde und so der letzte Ordnernamen etwas anders aussehen wird, weiterhin wurde hier eine Installation auf der D-Platte vorgenommen. Weiterhin ist es sinnvoll, eine weitere Variable JDK_HOME mit genau dem gleichen Wert anzulegen. Seite 18 von 136

19 Abschließend muss Java in die PATH-Variable eingetragen werden. Dazu wird die Path- Variable ausgewählt und Bearbeiten... geklickt. Der Pfad muss irgendwo um das Java-Verzeichnis verlängert um \bin ergänzt werden. Danach werden alle Änderungen mehrfach über OK bestätigt. Man beachte, dass einzelne Einträge in der Pfad-Variablen mit einem Semikolon getrennt sind. Im Beispiel wurde der Pfad beginnend mit einem Semikolon hinten angehängt. Seite 19 von 136

20 3 Installation von BlueJ Das Programm kann unter heruntergeladen werden. Die Installation startet über einen Doppelklick auf der heruntergeladenen Datei. Seite 20 von 136

21 Bei der Installation könnte sich die Firewall oder ein anderes Schutzprogramm melden, bei denen dann die Erlaubnis zur Installation erteilt werden muss. Eine Beispielmeldung kann wie folgt aussehen. Auch bei der Firewall muss gegebenenfalls eine Installationserlaubnis eingetragen werden. Seite 21 von 136

22 Die hier privat genutzte Firewall benötigt eine weitere Bestätigung, dass das Programm im normalen Modus installiert werden soll. Seite 22 von 136

23 Die Startmeldung wird gelesen und mit Next der Installationsprozess fortgesetzt. Seite 23 von 136

24 Danach wird geprüft, ob eine korrekte Java-Installation vorliegt, dies kann mit Next bestätigt werden. Seite 24 von 136

25 Man kann entscheiden, für wen die Installation zugängig sein soll und mir Next bestätigen. Man kann dann einige Einstellungen vornehmen, die Verknüpfung mit der Endung.bluej ist sehr sinnvoll, der Rest Geschmackssache. Die Einstellungen werden mit Next bestätigt. Seite 25 von 136

26 Man wird dann aufgefordert, ein Verzeichnis anzugeben, in dem BlueJ installiert werden soll. Danach wird Next geklickt. Danach kann die eigentliche Installation begonnen werden. Seite 26 von 136

27 Die Installation dauert etwas, gegebenenfalls sind Freigaben bei einem lokal installierten Systemüberwachungsprogramm notwendig. Man wird über die abgeschlossene Installation informiert, die mit Finish beendet wird. Seite 27 von 136

28 Nach erfolgreicher Installation hat man, insofern man es bei den Einstellungen zugelassen hat, auf dem Desktop folgendes Icon. Seite 28 von 136

29 4 Erste Nutzung von BlueJ 4.1 Anlegen eines Projektes BlueJ wird z. B. durch einen Doppelklick auf das Icon gestartet. Beim ersten Start prüft BlueJ, ob eine Java-Installation gefunden wird. Sind mehrere vorhanden, muss jetzt eine, typischerweise die neueste, ausgewählt und Launch geklickt werden. Abhangig von der Rechnerinstallation muss die Software zuerst von der Firewall die Erlaubnis zum Starten bekommen. Seite 29 von 136

30 Weiterhin muss der Start von java erlaubt werden, da BlueJ selbst in Java geschrieben ist und auf die Java-Installation zugreift. Seite 30 von 136

31 Danach zeigt sich eine recht einfache, aufgeräumte Entwicklungsumgebung. Seite 31 von 136

32 Die gesamte Entwicklung findet in BlueJ in getrennten Projekten statt, so dass man z. B. pro Aufgabe ein eigenes Projekt anlegen sollte. Für ein neues Projekt wählt man Project -> New Project. Seite 32 von 136

33 Im sich öffnenden Dateibrowser sollte man zu einem eigenen Verzeichnis manövrieren, in dem man das Projekt anlegen möchte. Man kann dieses Verzeichnis auch direkt in diesem Fenster erstellen, in dem man im oberen Fensterteil einen Rechtsklick macht und Neuer Ordner auswählt. Der Ordner heißt im Beispiel BlueJWork12. Seite 33 von 136

34 Ist der Ordner dann angelegt, steuert man in diesen Ordner und wählt einen Dateinamen für das neue Projekt, hier ErstesMal aus und klickt Create. Das BlueJ-Fenster verändert seine Farbe, die Knöpfe auf der linken Seite werden nutzbar und ein Zettel liegt im Arbeitsbereich, der aus Interesse jetzt einmal mit einem Doppelklick angeklickt wird. Seite 34 von 136

35 Es öffnet sich ein Editor mit der zum Projekt gehörenden Datei README.TXT in der man eine Projektbeschreibung eintragen kann. Der Editor kann über den Knopf Close verlassen werden. Seite 35 von 136

36 4.2 Laden eines existierenden Projekts Um ein existierendes Projekt zu laden, wird nach dem Start von BlueJ Project -> Open Project gewählt. Danach wird zum existierenden Projekt gesteuert und dies mit Open geöffnet. Seite 36 von 136

37 Ist eine Verknüpfung zwischen der Endung.bluej und dem Programm BlueJ wie bei der Installation beschrieben, erstellt worden, kann man Projekte auch mit einem Doppelklick öffnen. 4.3 Erstellung einer ersten Klasse Nachdem man ein Projekt angelegt hat, kann man mit der eigentlichen Entwicklung starten. Hierzu wird zunächst New Class geklickt, um eine erste Klasse zu erstellen. Seite 37 von 136

38 Die neue Klasse muss einen Klassennamen haben, der im Feld Class Name: eingetragen wird. Der Name soll mit einem Großbuchstaben beginnen und nur kleine und große Buchstaben, als Ausnahme auch Ziffern, niemals aber Umlaute oder Sonderzeichen, beinhalten. Hier wird eine Klasse Student angelegt. Der Klassentyp kann weiterhin auch über Class Type gewählt werden. Hier kann die Standardeinstellung genutzt werden. Die Eingabe wird mit einem Klick auf Ok abgeschlossen. Im Arbeitsbereich wird jetzt die Klasse angezeigt, die mit gedrückter linker Maustaste beliebig im Arbeitsbereich platziert werden kann. Fährt man mit der Maus über die rechte untere Ecke der Klasse, erkennt man die Möglichkeit, mit gedrückter linker Maustaste die Größe der Klasse zu ändern. Seite 38 von 136

39 Um die Klasse mit Leben zu füllen, wird ein Rechtsklick auf der Klasse gemacht und Open Editor ausgewählt, alternativ kann ein Doppelklick auf der Klasse ausgeführt werden. Es öffnet sich ein Editor, der schon bemerkenswert viel vermeintlichen Programmcode enthält. Seite 39 von 136

40 Der enthaltene Text zeigt die typische Struktur einer Klasse. Man kann den Text schrittweise durch die eigene Implementierung ersetzen oder einfach alle Informationen innerhalb der geschweiften Klammern der Klasse löschen. Das Markieren erfolgt wie üblich mit gedrückter linker Maustaste oder mit der Tastenkombination Strg-A. Das Entfernen ist z. B. über den Cut -Knopf möglich. Seite 40 von 136

41 Man kann dann seinen eigenen Code eingeben, wobei man den oberen Kommentar ruhig stehenlassen kann, der im Verlauf des Beispiels aber mit gelöscht wird. Nach etwas Tipperei kann die Klasse wie folgt aussehen, dabei sollte die Tabulator-Taste zum Einrücken genutzt werden. Möchte man eine Tabulatorposition rückwärts springen, wird Shift+Tabulator-Taste gedrückt. Weiterhin sollte man für jede öffnende Klammer zunächst die schließende Klammer eingeben und dann den Bereich zwischen den Klammern füllen. Man beachte weiterhin, dass hier eine andere Variante der Zuordnung der Position der öffnenden zur schließenden Klammer stattfindet, als im vorgegebenen Beispiel. Hier ist es nur wichtig, projektweit die einheitliche Formatierung zu nutzen. Um die korrekte Syntax zu Seite 41 von 136

42 überprüfen, wird der Compile -Knopf gedrückt. Das sollte man immer nach der Eingabe einer Exemplarvariable oder Methode machen, um frühzeitig Fehler zu erkennen. Dies ist der zentrale Gedanke, bei der Entwicklung inkrementell vorzugehen und sich schrittweise von einer funktionierenden Teillösung zur nächsten funktionierenden Teillösung weiterzuhangeln. Die vorherige Abbildung zeigt am linken Rand Zeilenummern, die zunächst nicht eingeblendet sind. Da diese u. a. die Beschreibung von Fehlerorten erleichtern, wird hier kurz eingeschoben, wie sie eingeschaltet werden können. Hierzu klickt man auf Options und wählt Preferences. Seite 42 von 136

43 Man wählt den Reiter Editor falls dieser noch nicht ausgewählt ist, setzt den Haken bei Display line numbers auf der linken Seite und drückt Ok. Im Fehlerfall bei der Eingabe syntaktisch falschem Programmcodes (hier die letzte Methode), wird der problematische Programmcode markiert und man erhält im unteren Ausgabefeld einen Hinweis auf den Fehler. Genauer auf den ersten gefundenen Fehler, weitere Fehler werden nicht angezeigt. Seite 43 von 136

44 Man beachte, dass bei der Fehlererkennung zwar das Finden nicht schwierig ist, die Gestaltung einer sinnvollen Fehlermeldung aber oft schwer bis unmöglich ist. Erfahrene Entwickler wissen deshalb, dass man nicht unbedingt der angezeigten Fehlermeldung trauen kann und man den Fehler auch im umgebenden Programmcode der markierten Stelle suchen muss. Besonders kritisch sind hier vergessene Klammern, da dann irgendein nachfolgender Programmteil als Fehler markiert wird. Im folgenden Beispiel wurde die schließende Klammer des Konstruktors vergessen und die Folgezeile als kritisch markiert. Seite 44 von 136

45 Nach der Korrektur aller Syntax-Fehler erhält man die Meldung no syntax errors. Der Editor kann über Close jederzeit verlassen werden, da Änderungen sofort gespeichert sind, was sichtbar an der Meldung saved rechts unten im Fenster ist. Seite 45 von 136

46 Die Besonderheit des Editors ist es damit, dass alle Änderungen sofort gespeichert werden, man also nicht durch unvorsichtiges Schließen des Editors Änderungen verlieren kann. Mit dem Knopf Undo besteht trotzdem die Möglichkeit, die letzten Änderungen schrittweise wieder rückgängig zu machen. Bei geschweiften und runden Klammern ist es sehr hilfreich, dass, wenn der Cursor hinter der jeweiligen Klammer steht, die zugehörige öffnende oder schließende Klammer grau hinterlegt angezeigt wird. Bei größeren Programmierexperimenten kann es sinnvoll sein, Zwischenversionen der erstellten Software abzuspeichern, was hier in der Form von eigenen Projekten passiert. Versierte Entwickler können selbst herausfinden, wie man BlueJ mit einer Versionsverwaltung wie Subversion oder Git verknüpfen kann. Zur Speicherung der Zwischenlösung wird einfach Project -> SaveAs gewählt. Seite 46 von 136

47 Im Namen des Projekts kann man dann z. B. eine Versionsnummer eintragen, die beim erneuten Speichern dann manuell hochgezählt wird. Das Speichern erfolgt mit einem Klick auf den Knopf Save. Gerade Anfänger haben durch viele notwendige Änderungen oft das Problem, dass die Formatierung des Programms verloren geht, wie das folgende Beispiel zeigt. Seite 47 von 136

48 Hier hilft ein Klick auf Edit -> Auto-layout, um zu einer ordentlichen Formatierung zu kommen. Das Ergebnis sieht dann wie folgt aus. Seite 48 von 136

49 Abschließend sei angemerkt, dass der vorgestellte Editor sicherlich eine gewisse Qualität hat, die für echte Anfänger absolut ausreicht, da keine Überforderung mit den angebotenen Möglichkeiten erfolgt. Erfahrene Entwickler, und nur diese, können aber durchaus andere Editoren oder Entwicklungsumgebungen als Editoren nutzen, wie es im Kapitel 8 Seite 49 von 136

50 Nutzung eines alternativen Editors (Eclipse) beschrieben wird. 4.4 Kompilierung einer Klasse Bevor man Objekte von Klassen erstellen kann, müssen diese in Byte-Code übersetzt (kompiliert) werden, der dann von der Java-Virtual Machine ausgeführt wird. Eine noch nicht übersetzte Klasse erkennt man daran, dass sie schraffiert ist. Dies passiert z. B., wenn man den Editor einer Klasse schließt ohne als letzte Aktion ein Compile auszuführen. Bei größeren Projekten führt die Änderung einer Klasse dazu, dass alle anderen Klassen, die Objekte dieser Klasse nutzen, auch wieder kompiliert werden müssen. Zum Übersetzen macht man z. B. einen Rechtsklick auf der Klasse und wählt Compile. Alternativ kann der Knopf Compile auf der linken Seite genutzt werden. Danach ist die übersetzte Klasse als einfacher Rahmen dargestellt. Sollte das Programm gerade im Editor erstellt und dabei übersetzt worden sein, liegt sie bereits beim Schließen des Editors übersetzt zur Nutzung vor. Sollte beim Kompilieren ein Fehler gefunden werden, wird der Editor für diese Klasse geöffnet und der erste Fehler markiert. Seite 50 von 136

51 4.5 Erstellung eines Objektes einer Klasse Hat man ein oder mehrere Klassen in seinem Arbeitsbereich, kann man direkt von diesen Klassen Objekte (manchmal auch Instanzen genannt) erzeugen. Dies ist notwendig, damit der geschriebene Programmcode mit den Objektmethoden überhaupt ausgeführt werden kann. Es wird ein Rechtsklick auf der Klasse gemacht, dann werden im oberen Bereich alle nutzbaren Konstruktoren der Klasse beginnend mit new angezeigt, von denen einer ausgewählt werden muss. Nun müssen für die Parameter des Konstruktors die konkreten Werte angegeben werden. Weiterhin muss jedes Objekt einen individuellen Namen erhalten, die Eingabe wird mit Ok abgeschlossen. Man beachte, dass Texte (Objekte vom Typ String) in Hochkommata angegeben werden. Ohne diese Hochkommata würde die Eingabe als Variablenname interpretiert und geschaut, ob ein Wert für diese Variable bisher bekannt ist. Seite 51 von 136

52 Man sieht dann in der unteren Leiste von BlueJ die momentan nutzbaren Objekte, für die der Objektname und die Klasse angegeben werden. 4.6 Ausführung von Exemplarmethoden Durch einen Rechtsklick auf einem Objekt links-unten in der Objektleiste können mehrere Aktionen ausgeführt werden, wie z. B. die Änderung der Matrikelnummer mit dem Aufruf der zugehörigen set-methode. Seite 52 von 136

53 Für jede Methode müssen wieder Parameterwerte angegeben werden. Der kleine Pfeil rechts beim Eingabefeld ermöglicht eine Übersicht über bisher bekannte Eingabewerte. Neue Werte können einfach eingetippt und über Ok bestätigt werden. Seite 53 von 136

54 In dem vorherigen Fall wurde eine Methode ohne Rückgabewert genutzt, der Typ der Rückgabe ist void. Bei solchen Methoden ist kein weiterer Effekt bei der Ausführung beobachtbar. Hat die aufgerufene Methode ein Ergebnis, wird dieses angezeigt und kann, wenn es sich um ein Objekt handelt, weiter untersucht werden. Es wird jetzt die getname()- Methode aufgerufen. Man erhält ein Ergebnisobjekt, das mit den im folgenden Abschnitt beschriebenen Verfahren auch über Inspect genauer betrachtet werden kann. Seite 54 von 136

55 Wählt man im vorherigen Fenster den Get -Knopf, wird das Ergebnisobjekt zur Objektleiste hinzugefügt, dazu muss dem Objekt zunächst ein eindeutiger Name gegeben und mit OK bestätigt werden. Danach befindet sich das Objekt in der Objektleiste und kann bei Bedarf über einen Rechtsklick mit der Auswahl von Remove auch wieder gelöscht werden. 4.7 Genaue Analyse eines Objekts Möchte man sich die Eigenschaften eines Objekts ansehen, wählt man nach einem Rechtsklick auf dem Objekt den Punkt Inspect oder macht einen Doppelklick auf dem Objekt. Seite 55 von 136

56 Man erhält dann eine Übersicht über die aktuellen Werte der Exemplarvariablen. Über den Knopf Show static fields könnte man zu den Klassenvariablen gelangen. Sollte es sich bei den Werten wiederum um Objekte handeln, kann man die Variable anklicken damit dann der Knopf Inspect nutzbar wird und geklickt werden kann. Da Strings auch Objekte sind, ist hier ein Inspect möglich. Seite 56 von 136

57 Ohne auf Details einzugehen, erkennt man, dass der String u. a. aus einem char-array besteht, der zwei Elemente (count) enthält. Beim char-array kann wieder Inspect wählen. Von dem Array sind seine Länge und der Inhalt der einzelnen Felder bekannt, die mit ihrer Position im Array ausgegeben werden. Über Close können die Objekt-Ansichten wieder geschlossen werden. 4.8 Nutzung des Code Pad Beim Code Pad handelt es sich um eine Komponente von BlueJ, mit der kleine Code- Fragmente ausgeführt und Ergebnisse von Methodenaufrufen direkt sichtbar gemacht werden können. Das Code Pad wird mit View -> Show Code Pad rechts unten in BlueJ sichtbar. Seite 57 von 136

58 Vorweg sei angemerkt, dass erstellte Objekte und in Code Pad erstellte Skripte nach der Beendung von BlueJ nicht mehr zur Verfügung stehen, da sie als nicht permanent nutzbares Material angesehen werden. Zunächst können im Code Pad einfache Java-Anweisungen eingetippt werden. Seite 58 von 136

59 Drückt man dann ENTER wird das Programmfragment ausgeführt und das Ergebnis mit seinem Typen angezeigt. Ergebnisse solcher Berechnungen können auch Objekte sein (war bei der ersten Anfrage bereits der Fall), dann wird am linken Rand von Code Pad ein kleiner roter Kasten als Repräsentant für das Ergebnisobjekt angezeigt. Seite 59 von 136

60 Dieses Objekt kann jetzt mit gedrückter linker Maustaste in den Bereich mit den Objekten links-unten in BlueJ gezogen werden. Lässt man die Maustaste, also das Objekt, los, wird man nach einem Namen für das Objekt gefragt, der dann mit OK bestätigt wird. Seite 60 von 136

61 Danach kann das Objekt genau wie die anderen existierenden Objekte genutzt werden. Das Bild zeigt die Ausgabe, nachdem ein Inspect auf dem Objekt ausgeführt wurde. Möchte man ein Ergebnisobjekt nur genauer betrachten (inspect), ohne es in den Objekt- Bereich zu legen, kann man dies durch einen Doppelklick auf das kleine Objekt am linken Rand erreichen. Man erkennt dann in der Kopfzeile, dass das Objekt dann keinen Namen hat. Seite 61 von 136

62 Das folgende Bild zeigt weitere Java-Programmzeilen, die einfach im Code Pad ausgeführt werden können. Um Code über mehrere Zeilen schreiben zu können, muss am Zeilenende jeweils Shift-ENTER gedrückt werden, was am linken Rand jeweils durch zwei Pünktchen sichtbar wird. Hat man einen Tippfehler gemacht oder möchte frühere Zeilen wiederholen, kann dies durch die Pfeiltasten (nach oben für vorherigen Befehl) erfolgen. Die Zeilen werden einzeln eingeblendet, können aber mit shift+enter wieder zu einem längeren Befehl zusammengesetzt werden. Werden Programmzeilen mit einem Semikolon beendet, wird erwartet, dass es sich hierbei um mehrere Programmzeilen handelt, die vor einer Bearbeitung ausgeführt werden sollen. Man kann aber auch später auf Ergebnisse der Berechnung zugreifen, indem wie im folgenden Beispiel einfach der Name des Objekts als Befehl eingegeben wird. Auffällig ist dabei, dass der in Code Pad vergebene Name student3 weder bei der Inspection noch bei einem Ziehen in den Objektbereich genutzt wird. Seite 62 von 136

63 4.9 Weitere Nutzung von Objekten Objekte in der Objektleiste können auch weiter bei der Objekterstellung oder bei Methodenaufrufen als Parameter genutzt werden. Die folgende Abbildung zeigt, wie zunächst im Code Pad ein neues Objekt s1 angelegt wird, dass dann in die Objektleiste gezogen wird und wieder den Namen s1 erhält. Im nächsten Schritt wird der Konstruktor der Klasse direkt aufgerufen und beim Fach das Fach des Objektes s1 genutzt. Seite 63 von 136

64 Die Inspektion zeigt, dass der Ansatz erfolgreich war. Seite 64 von 136

65 Die folgende Abbildung zeigt, dass man auch von Code Pad aus auf Objekte der Objektleiste über deren Namen zugreifen kann. Es wird auch deutlich, dass man zur Ausgabe von Rückgabewerten kein Semikolon in die Zeile setzen darf. Seite 65 von 136

66 5 Arbeiten mit mehreren Klassen in BlueJ 5.1 Laden externer Klassen Möchte man Klassen nutzen, die in anderen Projekten entwickelt wurden, muss man diese in das neue Projekt integrieren. Als Beispiel soll die Klasse EinUndAusgabe.java geladen werden, die sich im Ordner C:\downloads befindet. Zum Einlesen wählt kann man Edit -> Add Class from File. Nun wird im Datei-Browser die Klasse gesucht und dann Add geklickt. Seite 66 von 136

67 Man sieht, dass die Klasse geladen, aber noch nicht kompiliert wurde, was z. B. mit einem Klick auf Compile möglich ist. Die Datei EinUndAusgabe.java wurde als echte Kopie in das Projekt geladen. Damit würden Änderungen an dieser Klasse nicht zu Änderungen in der Ursprungsklasse führen. Seite 67 von 136

68 5.2 Nutzung der Eingabeklasse Zunächst ist es sinnvoll, die Ein- und Ausgabe-Konsole (Terminal) über View -> Show Terminal sichtbar zu machen. Hier werden Ausgaben von Programmen sichtbar, weiterhin kann der Nutzer hier Eingaben machen. Möchte man Methoden aufrufen, erzeugt man sich ein Objekt, macht einen Rechtsklick auf dem Objekt und wählt die gewünschte Methode aus. Da in diesem Fall die Methode eine Konsoleneingabe erwartet, kann man kann jetzt über das Terminal Window einen Wert eintippen und die Eingabe mit ENTER abschließen. Seite 68 von 136

69 Nach der Eingabe wird die Rückgabe der Methode als untersuchbarer Wert ausgegeben. Im aktuellen Fall ist es ein einfacher Integer-Wert. Nun wird eine Methode aufgerufen, die ein Objekt, hier einen String zurückliefert. Seite 69 von 136

70 Die Eingabe erfolgt wieder über das Terminal Window. Sollten alte Eingaben stören, können diese über Options -> Clear gelöscht werden. Ohne Löschen wird jetzt ein String eingegeben, der auch Leerzeichen enthalten kann. Seite 70 von 136

71 Man erhält das Ergebnis-Objekt, das mit Inspect untersucht werden kann. Man kann dann wieder die innere Objektstruktur betrachten, deren Details hier aber nicht interessieren. Ähnlich zur Eingabe funktioniert auch die Ausgabe, hier wird die Methode ausgeben() aufgerufen. Seite 71 von 136

72 Als Parameter wird das auszugebende Objekt angegeben, hier ein String-Objekt. Die Ausgabe folgt im vorher gelöschten Terminal Window. Durch Ausprobieren kann man auch herausbekommen, dass man im Terminal Window keine eingaben machen kann, wenn es nicht ein laufendes Programm mit Eingabeaufforderung gibt. Seite 72 von 136

73 Ein kleines Beispielprogramm im Code Pad kann wie folgt aussehen. Zunächst wird ein Text als Eingabeaufforderung ausgegeben und dann soll ein String-Objekt eingelesen werden, dessen Referenz mit der Variable ein verknüpft wird. Nach Eingabe des Textes kann das Programm mit einer Ausgabe des vorher eingegebenen Textes verlängert werden. 5.3 Ein einfaches Programm mit Nutzung einer Sammlung Der folgende Abschnitt beschreibt die Erstellung eines Programms zur Verwaltung neuer Studenten-Objekte. Dabei werden die bisher beschriebenen Klassen Student und Eingabe genutzt. Die Grundidee ist, dass es eine weitere Verwaltungsklasse gibt, die alle Studenten- Objekte kennt und einen Dialog anbietet, mit dem man die Studierenden bearbeiten kann. Man beachte, dass die Programmierung hier auf relativem Anfänger-Niveau passiert, da die Eingabe nicht von der Verwaltung der Objekte getrennt wird und statt einer wahrscheinlich sinnvolleren Nutzung des Sammlungstyps Map auf eine eventuell einfacher verständliche List zurückgegriffen wird. Zunächst wird eine neue Klasse Studentenverwaltung angelegt und der Programmeditor mit einem Doppelklick geöffnet, der Beispieltext gelöscht, einige Zeilen programmiert und der Compile -Knopf gedrückt. Seite 73 von 136

74 Man erhält eine Fehlermeldung, da die Klasse ArrayList noch nicht bekannt ist. Leider bietet der Editor keine Unterstützung, möglichst einfach bekannte Klassen aus der Klassenbibliothek einzubinden. Die benötigte import-zeile wird eingetippt und nach erfolgreicher Kompilierung fällt auf, dass im Klasseneditor eine gestrichelte Linie ergänzt wird. Diese Linie gibt an, dass die Klasse Studentenverwaltung die Klasse Student nutzt, also von dieser Klasse abhängig ist. Konkreter gilt, dass ein Objekt der Klasse Studentenverwaltung beliebig viele Objekte der Klasse Student nutzt. Statt diese Abhängigkeit berechnen zu lassen, kann man diese auch von Hand eintragen, indem der gestrichelte Pfeil im Klasseneditor und dann die nutzende sowie danach die genutzte Klasse angeklickt wird. Das Layout der Pfeile kann man leider nicht beeinflussen. Weiterhin hat der Klasseneditor neben der später beschriebenen Vererbung keine weiteren Möglichkeiten, Klassendiagramme als UML-Klassendiagrammen darzustellen, die die in der Software-Entwicklung standardmäßig eingesetzte Notation ist. Seite 74 von 136

75 Das Programm wird jetzt schrittweise, durch mehrfaches Kompilieren und Weiterschreiben entwickelt. Hat man dann ein Programmstück abgeschlossen, kann man es sehr gut mit dem Code Pad manuell überprüfen. Im folgenden Beispiel wurde der Nutzungsdialog eingegeben und man kann prüfen, dass das Programm mit der Eingabe der Zahl Null terminiert. Seite 75 von 136

76 Als Hinweis am Rande sei vermerkt, dass man in Java in Texten zwar deutsche Umlaute verwenden kann, dieses aber vermieden werden sollte. Das Problem kann auch direkt auftreten, wenn man Dateien zwischen Windows- und Unix-Systemen (Solaris, Linux, Mac OS) austauscht. Man sollte folgende Unicode-Zeichen verwenden und z. B. eine Web-Quelle wie dazu verlinken. Seite 76 von 136

77 Zeichen Unicode Ä, ä \u00c4, \u00e4 Ö, ö \u00d6, \u00f6 Ü, ü \u00dc, \u00fc ß \u00df Zum Ausprobieren kann natürlich alternativ ein Objekt der Klasse Studentenverwaltung angelegt und im Code Pad die Methode dialog() aufgerufen werden. Man erkennt leider nicht auf den ersten Blick, dass das Programm läuft, dazu gibt es aber drei Indikatoren. Der wichtigste Punkt ist der laufende rote Balken am linken Rand des Bildes (1). Weiterhin wird im Code Pad kein kleiner Pfeil angezeigt, dass eine weitere Eingabe möglich ist (2). Nur bei laufenden Programmen, die aktuell eine Eingabe erwarten, können Zeichen im Terminal Window eingegeben werden, was am Cursor-Symbol (3) deutlich wird Nach einigen Tests wird das Programm mit der Eingabe 0 beendet. Seite 77 von 136

78 Wenn Klassen dem Editor bekannt sind, unterstützt er die sogenannte Code Completion, bei der er Vorschläge generiert, welche Methode genutzt werden soll. Nach dem letzten Programmstück ist die Verknüpfung zur Klasse EinUndAusgabe bekannt, von dessen Typ es eine Objektvariable io gibt, so dass man nach der Eingabe von io. und dem Drücken von Strg+Leertaste ein Angebot an nutzbaren Methoden erhält, die dann mit einem Mausklick oder durch die Tasten Pfeil-hoch und Pfeil-runter ausgewählt werden können. Dieser Ansatz kann die Anzahl von Tippfehlern deutlich minimieren, weiterhin muss man sich bei Klassen wie ArrayList nicht alle Methoden merken oder permanent nachschlagen. Seite 78 von 136

79 Man kann auch dann einzelne Buchstaben als Anfang des Methodennamens eintippen, so dass die Auswahl dann eingeschränkt wird. Falls zur Methode eine Dokumentation in JavaDoc vorliegt, wird diese rechts mit angezeigt. Neben der möglichen großen Anzahl an Fenstern in BlueJ, die man im Überblick behalten sollte, muss man auch beachten, dass man eine Klasse nicht dann übersetzen kann, wenn das Programm gerade läuft. Man erkennt das laufende Programm an dem animierten Querbalken. Macht man einen Rechtsklick auf diesen Balken, kann man die Java Virtual Machine, also das für die Ausführung von Java-Programmen zuständige Programm stoppen und neu starten. Dies ist ein Seite 79 von 136

80 recht drastischer Schritt und sollte nur genutzt werden, wenn keine anderen Möglichkeiten bestehen Das resultierende Programm sieht dann wie folgt aus. /** S. Kleuker V 1.0 */ import java.util.arraylist; public class Studentenverwaltung{ private ArrayList<Student> studenten; private EinUndAusgabe io; public Studentenverwaltung(){ this.studenten = new ArrayList<Student>(); this.io = new EinUndAusgabe(); } public void dialog(){ Integer eingabe = -1; while (eingabe!= 0){ this.io.ausgeben("was soll gemacht werden?\n" +" (0) Programm beenden\n" +" (1) Studenten hinzuf\u00fcgen\n" +" (2) Studenten mit Matrikelnummer suchen\n" ); eingabe = this.io.leseinteger(); switch (eingabe) { case 1:{ studenthinzufuegen(); break; } case 2:{ studentsuchen(); break; } } } } private void studenthinzufuegen(){ this.io.ausgeben("matrikelnummer: "); Integer mat = this.io.leseinteger(); this.io.ausgeben("name: "); String name = this.io.lesestring(); this.io.ausgeben("fach: "); String fach = this.io.lesestring(); if(matrikelnummerexistiert(mat)){ Seite 80 von 136

81 } this.io.ausgeben("keine doppelten Matrikelnummern\n"); } else { Student neu = new Student(mat, name, fach); studenthinzufuegen(neu); this.io.ausgeben("hinzugef\u00fcgt: "+neu+"\n"); } public void studenthinzufuegen(student s){ this.studenten.add(s); } public Boolean matrikelnummerexistiert(integer mat){ Boolean ergebnis = false; Student tmp = studentsuchen(mat); if(tmp!= null){ ergebnis = true; } return ergebnis; } public void studentsuchen(){ this.io.ausgeben("welche Matrikelnummer? "); Integer mat = this.io.leseinteger(); Student std = studentsuchen(mat); if (std == null){ this.io.ausgeben("student nicht gefunden\n"); } else { this.io.ausgeben(std+"\n"); } } } public Student studentsuchen(integer matrikelnummer){ Student ergebnis = null; for(student s:studenten){ if (s.getmatrikelnummer() == matrikelnummer){ ergebnis = s; } } return ergebnis; } Das Programm kann dann interaktiv mit Nutzereingaben getestet werden. Optional kann man beim Terminal Window unter Options -> Record method calls einstellen, dass die durchgeführten Methodenaufrufe, dann in einem weiteren Terminal Window, mit angezeigt werden. Ob dies hilfreich ist, da z. B. keine internen Methodenaufrufe sichtbar werden, muss jeder für sich selbst entscheiden. Seite 81 von 136

82 Ein Beispielablauf mit den zugehörigen Methodenaufrufen, nachdem ein Objekt sv der Klasse Studentenverwaltung erstellt wurde, kann wie folgt aussehen. Seite 82 von 136

83 Seite 83 von 136

84 6 Nutzung des Debuggers Oftmals stellt man in der Programmausführung fest, dass sich das Programm nicht wie gewünscht verhält. Zunächst sollte man versuchen, durch kritisches Lesen des Programmcodes auf den Fehler zu stoßen. Findet man den Fehler nicht, sollte man es unbedingt vermeiden, durch unsystematische Versuche doch noch zum laufenden Programm zu kommen. Dies ist gerade bei Anfängern ein gern gemachter Fehler und führt dann zu meist nur vermeintlich korrekten Programmen, deren Ablauf der Entwickler selbst nicht beschreiben kann. Eine Lösung ist das Einfügen von zusätzlichen Ausgabezeilen, die die momentanen Werte der aktuellen Variablen anzeigen. Systematischer ist die Nutzung eines Debuggers, mit dem man genau den Ablauf eines Programms mit allen Werten der Variablen verfolgen kann. Typischerweise wird eine Zeile so markiert, dass die virtuelle Maschine bei der Ausführung des Java-Programms weiß, dass jetzt der Debugger gestartet werden soll. Als Beispiel dient das Programm aus dem Kapitel 5.3 bei dem in der Zeile 63 statt tmp!=null nun tmp==null steht. Bei der Programmausführung scheitert bereits das erste Einfügen eines Studenten. Seite 84 von 136

85 Nach erfolgloser Fehlersuche stellt man fest, dass die Eingabe wohl noch funktioniert, danach aber irgendwann der Fehler auftritt. Aus diesem Grund wird unmittelbar nach der Eingabe ein sogenannter Breakpoint (Unterbrechungspunkt) gesetzt, der bei der nächsten Ausführung dazu führt, dass der Debugger aufgerufen wird. Der Breakpoint wird durch einen einfachen Klick auf der Zeilenummer gesetzt, was nur bei einem kompilierten Programm möglich ist. Seite 85 von 136

86 Nun wird ein Objekt der Klasse Studentenverwaltung erzeugt und der Dialog aufgerufen. Unmittelbar nach der Eingabe des neuen Studenten öffnet sich der Debugger und im Programmcode ist die Zeile, die gerade ausgeführt werden soll, markiert. Seite 86 von 136

87 Der Debugger bietet in der unteren Zeile fünf verschiedene Funktionen an. Die ausgegraute ganz links heißt Halt mit der z. B. eine länger laufende Ausgabe abgebrochen werden kann. Mit Step wird der nächste Schritt ausgeführt, dabei werden anstehende Methodenaufrufe einfach ausgeführt, man bleibt also in der gerade ausgeführten Methode und man bekommt vom eventuell anstehenden Methodenaufruf nur mit, dass diese ausgeführt wurde. Mit Step Into wird bei einem in der Zeile befindlichen Methodenaufruf in diese Methode gesprungen, so dass als nächster Schritt der erste Schritt dieser Methode ausgeführt wird. Mit Terminate kann das gesamte Programm z. B. nach erfolgreicher Fehlersuche abgebrochen werden. Weiterhin können hiermit auch Programme abgebrochen werden, wenn der Debugger nicht läuft. Dafür kann dieser mit View -> Show Debugger sichtbar gemacht werden. Seite 87 von 136

88 Im Debugger sieht man links unter Call Sequence die Methodenaufrufe, die zur aktuellen Zeile geführt haben. Durch Anklicken der Methode wird auf der rechten Seite die momentane Situation in der Methode, d. h. die Werte der Variablen, sichtbar. Rechts unter Static variables stehen die Klassenvariablen, unter Instance Variables die Objektvariablen und unter Local Variables die lokalen Variablen der Methode. Bei den lokalen Variablen werden auch Parameter des Methodenaufrufs angezeigt. Durch einen Doppelklick auf eine Variable wird die Inspection der Variable ermöglicht. Die folgende Abbildung zeigt dies für zwei Variablen. Seite 88 von 136

89 Im Debugger wird jetzt Step Into aufgerufen. Was man an der Call Sequence, den neuen lokalen Variablen und der jetzt markierten Zeile erkennt. Seite 89 von 136

90 Da jetzt keine Methodenaufrufe anstehen, haben Step und Step Into die gleiche Bedeutung. Nach einigen Schritten mit Step Into erkennt man, dass die Methode studentsuchen mit ergebnis=null das gewünschte Ergebnis liefert. Seite 90 von 136

91 Wahrscheinlich erkennt man an folgender Stelle, dass hier das falsche Ergebnis durch die falsche Boolesche Bedingung zurückgeliefert wird. Danach kann das Debuggen beendet werden. Seite 91 von 136

92 Das Fenster kann einfach geschlossen und das Programm neu übersetzt werden. Der Breakpoint sollte vor der nächsten Ausführung gelöscht werden. Seite 92 von 136

93 7 Testen Um zu prüfen, ob eine Software das gewünschte Verhalten hat, gibt es neben dem reinen Ausprobieren und der Erstellung einer neuen Klasse, die die zu testende Klasse nutzt, auch die Möglichkeit, Testfälle direkt in Java so zu programmieren, dass man sie später bei Änderungen auch weiter nutzen kann. Dieses Kapitel zeigt die Nutzung von JUnit zur Prüfung von Methoden. Es sei angemerkt, dass die systematische Qualitätssicherung ein komplexes Aufgabenfeld mit vielen Möglichkeiten auch im Testbereich ist. Weiterhin muss sich ein Entwickler immer verdeutlichen, dass nur gezeigt wird, dass die Testfälle funktionieren, man daraus nie auf ein vollständig korrektes Verhalten schließen darf. BlueJ unterstützt neben dem hier beschriebenen Weg auch die Möglichkeit, Aktionen, wie das Erzeugen von Objekten und das Aufrufen von Methoden aufzuzeichnen, um dann daraus JUnit-Testfälle zu erzeugen. Dieser für einige Schritte auch interessante Weg kann in anderen BlueJ-Dokumentationen nachgelesen werden und wird hier nicht weiter betrachtet, da er recht BlueJ-spezifisch ist. Als Beispiel sollen die Methoden der Klasse Studentenverwaltung aus Kapitel 5.3 geprüft werden, in denen keine Nutzereingaben erfolgen. Der auch mögliche Test von Methoden mit Nutzereingaben wird hier nicht weiter verfolgt. Um effizient testen zu können, muss dies in der Software berücksichtigt werden. Dies ist in der bisher erstellten Software der Fall, da z. B. wesentliche Methoden matrikelnummerexistiert(.) und studentsuchen(.) die Sichtbarkeit public haben und deshalb von außen aufgerufen werden können. Es gilt, dass generell in einem Projekt entschieden werden muss, wie man die Testbarkeit der Software garantieren kann. 7.1 Erzeugen einer Testklasse Zum Erzeugen einer Testklasse drückt man z. B. New Class. Man wählt jetzt Unit Test. Der Name der Klasse ist beliebig, es ist aber üblich, den Namen der zu testenden Klasse um das Wort Test zu ergänzen. Seite 93 von 136

94 Es entsteht eine neue Klasse, die z. B. mit einem Doppelklick geöffnet wird. Die Klasse ist bereits mit einigem Programmcode gefüllt. Seite 94 von 136

95 Hier wird geraten, diesen Code vollständig zu löschen und durch folgenden Code zu ersetzen, bzw. die erste Zeile zu ändern und den Klasseninhalt zu löschen. Seite 95 von 136

96 import org.junit.assert; import org.junit.after; import org.junit.before; import org.junit.test; public class StudentenverwaltungTest{ } 7.2 Ausführung von Tests Danach werden schrittweise Testfälle ergänzt. Dies sind ganz normale Methoden, die Zusätzlich annotiert werden. Annotationen können von anderen Programmen genutzt werden, um bestimmte Aktionen auszuführen. Mit Annotationen wird deklasrativ programmiert, da man nur schreibt was gemacht werden soll, aber nicht wie es gemacht werden soll. Die Tests werden dann von JUnit ausgeführt, das Bestandteil von BlueJ und allen größeren Entwicklungsumgebungen ist. In den Tests beschreibt man mit Assert.assertTrue(<Bed>) Boolesche Bedingungen <Bed> von denen geprüft wird, ob Sie nach true ausgewertet werden. Bei einer Auswertung nach false, wird dies als Fehler von JUnit vermerkt. Die folgende Abbildung zeigt zwei Testfälle, die Methodennamen sind frei wählbar, beginnen aber üblicherweise mit test undbeinhalten den Namen der zu testenden Methode. Seite 96 von 136

97 Zur Ausführung der Testfälle wird ein Rechtklick auf der kompilierten Klasse gemacht und Test all ausgewählt. Man sieht, dass auch einzelne Tests ausgeführt werden können. Seite 97 von 136

98 Nach der Ausführung öffnet sich ein Ergebnisfenster, in der für jeden Test angezeigt wird, ob er erfolgreich war. Wichtig ist der grüne Balken in der Mitte, der zeigt, dass alle Tests ohne Fehler durchgelaufen sind. Nun werden noch zwei weitere Testfälle ergänzt, wobei der eine Testfall scheitern wird, da in diesem Fall der Testfall nicht in Ordnung ist. Generell gilt, dass man bei einem gescheiterten Test immer prüfen muss, ob die getestete Software oder der Test Fehler enthält. Im konkreten Beispiel werden zwar zwei gleiche Studenten erzeugt, da aber mit == auf Identität gefprüft wird, ist die Prüfung nicht erfolgreich. Seite 98 von 136

99 Das Ergebnis sieht wie folgt aus, man muss den Test anklicken, um unten Details angezeigt zu bekommen. Seite 99 von 136

100 Weiterhin kann man in JUnit eine einheitliche Testumgebung, eine Test-Fixture angeben, die für jeden Test benutzt wird. Die Grundidee ist, dass vor jedem Test die annotierte Methode, dann der Test und dann die annotierte Methode ausgeführt werden. Die korrigierte vollständige Testklasse sieht wie folgt aus. import org.junit.assert; import org.junit.after; import org.junit.before; import org.junit.test; public class StudentenverwaltungTest{ private Studentenverwaltung sv; private Student public void setup(){ sv = new Studentenverwaltung(); dummy = new Student(42,"Marvin","ROB"); public void testmatrikelnummerexistiertnicht(){ Assert.assertTrue(!sv.matrikelnummerExistiert(42)); public void testmatrikelnummerexistiert(){ sv.studenthinzufuegen(dummy); Assert.assertTrue(sv.matrikelnummerExistiert(42)); public void teststudentexistiertnicht(){ Assert.assertTrue(sv.studentSuchen(42)==null); } Seite 100 von 136

101 public void teststudentexistiert(){ sv.studenthinzufuegen(dummy); Assert.assertTrue(sv.studentSuchen(42) == dummy); } Seite 101 von 136

102 8 Nutzung eines alternativen Editors (Eclipse) BlueJ hat gegenüber anderen Entwicklungsumgebungen für Anfänger den elementaren Vorteil, dass man sich intensiv mit Klassen und den davon erzeugten Objekten sowie der schrittweisen Ausführung von Anweisungen beschäftigen kann. Dieser Ansatz ist durchaus auch für größere Projekte geeignet, wird in der Praxis aber nicht (kaum?) genutzt, u. a. weil BlueJ dort nicht bekannt ist. Ein passender Kritikpunkt an BlueJ ist der Programmeditor, der sich für Anfänger darauf konzentriert, möglichst nur die zentrale Funktionalität ohne Verwirrungsmöglichkeit anzubieten. Entwickler mit mehr Erfahrung wünschen sich dann zumindest einige der unzähligen Knöpfe hinzu, die andere Entwicklungsumgebungen anbieten. Bei der hier vorgestellten Variante wird Eclipse genutzt, wobei einige der Ideen auf andere auch als einfache Editoren nutzbare Entwicklungsumgebungen übertragbar sind. Generell ist nur zu beachten, dass die Quellcodedateien immer im BlueJ-Projektverzeichnis verbleiben und die Kompilierung entweder von BlueJ heraus passiert (bzw. wiederholt wird) oder dass die übersetzten Dateien (*.class) auch im gleichen BlueJ-Ordner wie der Quellcode (*.java) stehen. Es wird davon ausgegangen, dass die grundlegende Nutzung von Eclipse bekannt ist (auf den Seiten von Prof. Dr. Kleuker finden sich auch eine Anleitung hierzu), da sonst der hier vorgestellte Ansatz keinen Sinn macht. 8.1 Bearbeitung von BlueJ-Code aus Eclipse heraus Zunächst wird in Eclipse ein neues Projekt angegeben, dessen Name möglichst einen Bezug zum BlueJ-Projekt andeutet. In diesem Fall ist es BlueJErstesMal. Dazu wird in Eclipse File -> New Project gewählt. Es wird Java Project ausgewählt und Next> geklickt. Seite 102 von 136

103 Hier wird von oben nach unten zunächst ein Projektname (project name:) eingetragen, dann der Haken bei Use default location weggenommen und unter Location: zum Projektverzeichnis des BlueJ-Projekts mit dem Browse -Knopf gesteuert. Seite 103 von 136

104 Hier wird das genaue Projektverzeichnis ausgewählt und mit OK bestätigt. Seite 104 von 136

105 Dann wird unten auf Next> geklickt. Seite 105 von 136

106 Java-erfahrene Entwickler können auf der Folgeseite noch einige Einstellungen vornehmen, hier wird aber einfach Finish gedrückt, was man auch schon auf der vorherigen Seite hätte machen können. Seite 106 von 136

107 Danach ist das Projekt angelegt und man erkennt, dass die Source-Dateien unter Eclipse erkannt wurden. Weiterhin befindet sich die Ordnerstruktur des BlueJ-Projekts in Eclipse, die nicht bearbeitet werden darf. Mit einem Doppelklick auf einer Java-Datei wird der Eclipse- Quellcode-Editor geöffnet und kann genutzt werden. Seite 107 von 136

108 Das rote Kreuz bei StudentenverwaltungTest.java deutet auf einen Fehler hin, konkret ist JUnit noch nicht in das Projekt eingebunden. Hier reicht ein Linksklick auf die erste Fehlermeldung, bei dem dann Fix project setup ausgewählt wird. Mit einem Klick auf OK wird das Problem gelöst. Seite 108 von 136

109 Änderungen können jetzt einfach abgespeichert werden. Im Beispiel wird die untere tostring()-methode in der Klasse Student ergänzt und in Eclipse die Änderung abgespeichert. Falls man das Projekt parallel in BlueJ offen hat, was man eigentlich vermeiden sollte, da so zwei Programme um die Dateien konkurrieren, was auch für den Entwickler leicht irritierend werden kann, muss man beachten, dass zunächst immer noch die alte Implementierung genutzt wird (die in der mit BlueJ laufenden virtuellen Java-Maschine bekannt ist). Erzeugt man neue Objekte, steht die neue Methode nicht zur Verfügung. Seite 109 von 136

110 Um die Änderungen zu nutzen, muss einmal der Code-Editor von BlueJ geöffnet werden, was z. B. durch einen Doppelklick auf der geänderten Klasse passiert. Man sieht dann, dass die in Eclipse vorgenommenen Änderungen auch von BlueJ erkannt werden. Weiterhin zeigt das folgende Bild im Hintergrund, dass die geöffnete Klasse schraffiert wird, was bedeutet, dass keine aktuelle Kompilierung vorliegt. Zur Kompilierung wird einfach der Compile -Knopf gedrückt. Seite 110 von 136

111 Drückt man stattdessen den Close -Knopf, erkennt man an der Schraffur, dass BlueJ erkannt hat, dass keine aktuelle Kompilierung vorliegt, die dann über den Compile -Knopf nachgeholt werden kann. Seite 111 von 136

112 Nach dem Kompilieren sind automatisch alle veralteten Objekte in der unteren Objektleiste verschwunden, so dass neue aktuelle Objekte angelegt werden müssen. Seite 112 von 136

113 Hat man in BlueJ Änderungen am Quellcode vorgenommen, so erhält man bei der nächsten Nutzung des Projekts in Eclipse folgenden Hinweis auf nicht mehr aktuelle Dateien. Die Lösungsmöglichkeit wird bereits in der Fehlermeldung angegeben, es muss die F5-Taste gedrückt werden. Alternativ kann man auch einfach vor der Meldung das Projekt aktualisieren. Dazu wird ein Rechtsklick auf den Projektnamen gemacht und Refresh gewählt. Seite 113 von 136

114 8.2 Eclipse referenziert BlueJ-Dateien Statt Eclipse direkt auf dem Workspace von BlueJ arbeiten zu lassen, kann man auch mit Referenzen auf die Quellcode-Dateien von BlueJ arbeiten. Dazu wird wieder ein BlueJ- Projekt angelegt, das allerdings im auch sonst genutzten Workspace von Eclipse liegt. Seite 114 von 136

115 Nun werden aus dem BlueJ-Arbeitsverzeichnis heraus die Java-Dateien markiert und per Drag-und-Drop auf das neue EclipseProjekt in den Ordner src gezogen. Seite 115 von 136

116 Man hat dann die Möglichkeit, die Dateien zu kopieren, wodurch ein vollständig unabhängiges Projekt entsteht oder wie hier Link to files zu wählen, wodurch BlueJ und Eclipse vergleichbar zum Ansatz im vorherigen Abschnitt auf den gleichen Dateien arbeiten. Seite 116 von 136

117 Man erkennt an den kleinen Pfeilen, dass es sich um Links handelt. Der angezeigte Fehler bezieht sich auf das noch nicht eingebundene JUnit und kann wie im vorherigen Abschnitt beschrieben, beseitigt werden. Seite 117 von 136

118 9 Nutzung von nicht in BlueJ erstellten Projekten BlueJ kann recht einfach auf Projekte zugreifen, die mit anderen Entwicklungsumgebungen erstellt wurde. Typischerweise liegt der Quellcode dann in einem Ordner mit Namen src, der für weitere Pakete Unterordner hat. In BlueJ wird Project -> Open NonBlueJ ausgewählt. Nun wird zum src-verzeichnis, also generell zum Verzeichnis unter dem die Paket-Ordner liegen, gesteuert, dieses ausgewählt und Open in BlueJ ausgewählt. Seite 118 von 136

119 Man erhält dann die Projektstruktur in BlueJ nachgebildet. Zu beachten ist, dass das ursprüngliche Projekt um BlueJ-Informationen ergänzt wird. Seite 119 von 136

120 Wenn das Projekt geladen ist, kann man es auch als BlueJ-Projekt abspeichern, wobei echte Kopien des Quellcodes angelegt werden. Möchte man die Ausgangsdateien bearbeiten, werden die angelegten.bluej -Dateien in den Quellordnern genutzt. Das Speichern als eigenständiges Projekt erfolgt über Project -> Save As. Es kann ein eigenständiger Projektname gewählt und ein beliebiger Speicherort gewählt werden. Seite 120 von 136

121 Ein Blick auf die Festplatte zeigt, dass ein eigenständiges Projekt entstanden ist. Seite 121 von 136

122 10 Installation des Screenshot-Werkzeugs Faststone Capture Mit einem Screenshot-Werkzeug besteht die Möglichkeit, den aktuellen Monitorinhalt abzufotografieren und das entstandene Bild abzuspeichern. Solche Programme sind in verschiedenen Situationen sehr hilfreich, zwei wesentliche sind: - Die Erstellung einer Benutzungsdokumentation mit der die Bedienung der entstandenen Software beschrieben werden kann. Sehr hilfreich ist es dabei, wenn der Mauszeiger auch in den Bildern sichtbar wird. - Die Dokumentation von Fehlersituationen, dabei wird neben dem Programmcode ein Foto der aktuellen Situation auf dem Bildschirm ergänzt. Das Foto erspart oft eine langwierige Beschreibung, wie man zur kritischen Situation kommt. In der Programmierausbildung kann solch ein Werkzeug auch genutzt werden, um Fortschritte in der systematischen Programmerstellung zu dokumentieren. Die konkrete Auswahl des Werkzeugs ist dabei irrelevant. Hier wird exemplarisch das Werkzeug FastStone Capture vorgestellt, das allerdings nur bis zur völlig ausreichenden Version 5.3 frei genutzt werden kann. Es werden weiterhin nur grundlegende Funktionen vorgestellt, weitere Möglichkeiten des Programms kann man sich selbst erarbeiten Herunterladen und Installieren Da nicht die aktuellste, da kostenpflichtige, Version des Programms genutzt werden soll, muss man die freie Version finden. Eine gute Quelle ist die Web-Seite der Zeitung Chip, dabei z. B. folgender Link Freeware-Version_ html. Falls dieser nicht mehr funktioniert, sollte die Google Suche nach faststone capture freeware Erfolg bringen. Es wird der Knopf Zum Download gedrückt. Seite 122 von 136

123 Danach muss nochmals der angezeigte Link geklickt werden. Dann hängt es etwas von der Einstellung des Browsers ab, ob der Zum Download -Knopf noch gedrückt werden muss, oder ob der Download automatisch startet. Seite 123 von 136

124 Die Installation wird durch einen Doppelklick auf der heruntergeladenen Datei gestartet. Das Startfenster wird mit Next> verlassen. Seite 124 von 136

125 Die Lizenzbedingungen gelesen (u. a. Freeware für educational use) und mit I Agree bestätigt. Seite 125 von 136

126 Danach kann das Installationsverzeichnis gewählt werden und es wird Install gedrückt. Die Installation wird mit Finish abgeschlossen. Seite 126 von 136

127 10.2 Portable Alternative Das gleiche Programm gibt es auch als sogenannte portable Software. Diese hat den großen Vorteil nicht installiert werden zu müssen, so dass man sie ohne jedwede Rechte auf Rechnern nutzen kann. Das Programm trägt sich dann natürlich nicht in das Startmenü ein und muss jeweils direkt aufgerufen werden. Wer sich intensiver mit portabler Software beschäftigt, was ratsam für Personen sein kann, die auf mehreren Rechnern arbeiten und ihre Programme und Daten immer z. B. auf einem USB-Stick dabei haben wollen, wird schnell herausfinden, dass es auch Software zum Start und zur Verwaltung portabler Programme gibt. Ein Quelle zum Download ist z. B. Dort den Download-Link benutzen. Seite 127 von 136