Nutzungshinweise für BlueJ

Transkript

1 Thema: Autoren: Nutzung der Entwicklungsumgebung BlueJ Prof. Dr. Stephan Kleuker Version / Datum: 1.5 / Empfänger: Teilnehmer der Lehrveranstaltungen im Bereich Programmierung des Studiengangs Media & Interaction-Design 1 Vorbemerkungen Installation von Java Installation von BlueJ Erste Nutzung von BlueJ Anlegen eines Projektes Laden eines existierenden Projekts Erste Experimente mit dem Code Pad Erstellung einer ersten Klasse Kompilierung einer Klasse Erstellung eines Objektes einer Klasse Ausführung von Exemplarmethoden Genaue Analyse eines Objekts Weitere 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 Seite 1 von 157

2 10.1 Herunterladen und Installieren Portable Alternative Erste Schritte in der Nutzung Nutzung des Screenshot-Werkzeugs Shotty Starten Konfigurieren Nutzung Nutzung von Processing in BlueJ Einmalige Einrichtung der Nutzungsmöglichkeit Programmieren mit Processing Besonderheit beim Umgang mit float-werten Processing in weiteren Klasen nutzen Seite 2 von 157

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. Da hier eine Installation für eine Java-Version ab der Variante 7 beschrieben ist, kann zumindest der Download von der gleichen Seite erfolgen. 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 157

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 157

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 157

6 2 Installation von Java 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. Im ersten Schritt muss man zunächst die Java SE-Variante für die Standard Edition auswählen. Die anderen Varianten bieten keine Vorteile für Anfänger und enthalten teilweise nicht alle Bestandteile der Standard Edition. 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, hier wird Java SE 7u5 ausgewählt und unter JDK auf Download geklickt. Seite 6 von 157

7 Wichtig ist, dass ein JDK, ein Java Development Kit, heruntergeladen wird, da nur damit die eigene Entwicklung möglich ist. Mit einer JRE, einer Java Runtime Environment, können nur fertige Java-Programme ausgeführt werden. Zunächst liest man die Lizenzbedingungen (Link im mittleren Kasten) und klickt dann den Kreis links neben Accept License Agreement, um die Annahme der Lizenz zu bestätigen. Seite 7 von 157

8 Man wählt das Betriebssystem (hier die Beschreibung für Windows 32 Bit, meist x86 bezeichnet) und klickt den Link unter Download. Seite 8 von 157

9 Bei der folgenden Meldung hat man vergessen, oben die Lizenzbedingungen zu bestätigen. Dann kann der Download stattfinden. Seite 9 von 157

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

11 Nach einer eventuell notwendigen Bestätigung, dass die Installation durchgeführt werden soll, kann der sogenannte Installations-Wizard gestartet werden. Man beachte, dass in den folgenden Bildern keine Abfragen von Firewalls oder anderen individuell installierten Programmen beschrieben sind. Generell gilt, dass man Java die geforderten Rechte einräumt, was natürlich trotzdem auf eigene Gefahr passiert. Die Default-Einstellungen können übernommen werden, man sollte sich den Installationspfad merken. Seite 11 von 157

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

13 Sollten noch Programme offen sein, die eine vorherige Java-Installation nutzen, sind diese zu schließen, um dann die Installation fortzusetzen. Seite 13 von 157

14 Danach wird die Java-Installation abgeschlossen, wobei trotzdem ein Continue -Knopf zu drücken ist. Der dann startende interne Prozess wird ohne weiteres Fenster recht schnell abgeschlossen. Seite 14 von 157

15 Man hat dann noch die Möglichkeit Java FX zu installieren, was formal sehr wenig mit Java zu tun hat und mit Cancel einfach abgebrochen werden kann. Über eine Registrierung kann man nachdenken, wird aber nicht benötigt. Seite 15 von 157

16 Zum Abschluss muss 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 16 von 157

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

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

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

20 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 20 von 157

21 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. Man beachte, dass alle Einträge in Path mit einem Semikolon getrennt sind, wobei am Ende kein Semikolonstehen darf. Im Beispiel wurde der Pfad beginnend mit einem Semikolon hinten angehängt. Danach werden alle Änderungen mehrfach über OK bestätigt. Seite 21 von 157

22 3 Installation von BlueJ Das Programm kann unter heruntergeladen werden. Der Link zur Datei wird angeklickt und die zugehörige Datei heruntergeladen. Seite 22 von 157

23 Die Installation startet über einen Doppelklick auf der heruntergeladenen Datei. 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 23 von 157

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

25 Die Startmeldung wird gelesen und mit Next der Installationsprozess fortgesetzt. Seite 25 von 157

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

27 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 27 von 157

28 Man wird dann aufgefordert, ein Verzeichnis anzugeben, in dem BlueJ installiert werden soll. Danach wird Next geklickt. Danach kann die eigentliche Installation begonnen werden. Falls man die Installation nicht als Administrator durchgeführt hat, muss man noch die Installation bestätigen. Seite 28 von 157

29 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 29 von 157

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

31 4 Erste Nutzung von BlueJ 4.1 Anlegen eines Projektes Bevor man mit BlueJ arbeiten kann, muss man auch zum Experimentieren zunächst ein Projekt anlegen. Dazu wird BlueJ 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. Ist nur genau eine passende Java-Version vorhanden, wird diese genommen und das folgende Fenster erscheint nicht. Abhangig von der Rechnerinstallation muss die Software zuerst von der Firewall die Erlaubnis zum Starten bekommen. Seite 31 von 157

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

33 Danach zeigt sich eine recht einfache, aufgeräumte Entwicklungsumgebung. Seite 33 von 157

34 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 34 von 157

35 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 35 von 157

36 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 36 von 157

37 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 37 von 157

38 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 38 von 157

39 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. Auch hier können abhängig von der benutzen Firewall zunächst einige Genehmigungen von Zugriffen möglich sein. Dioe folgenden Abbildungen zeigen Beispiele, wenn man auf seinem privaten Rechner die Firewall Comodo nutzt. Seite 39 von 157

40 4.3 Erste Experimente mit dem Code Pad Java ist eine Programmiersprache, die kompiliert wird. Die dann entstehenden Dateien können dann auf den Rechner ausgeführt werden. Genauer entsteht beim Kompilieren sogenannter Byte-Code, der dann auf jedem Rechner ausgeführt werden kann, auf dem eine Java Virtual Machine, genauer eine Java Runtime Edition (JRE) installiert ist. Seite 40 von 157

41 Damit ist Java eine Programmiersprache, die nicht unmittelbar nach Eingabe der Befehle ausgeführt werden kann, wie es bei Skriptsprachen, wie JavaScript (hat nichts mit Java zu tun) und PHP der Fall ist. Da das sofortige Ausführen von Befehlen mit der Möglichkeit unmittelbar die Ergebnisse zu sehen, gerade für Anfänger eine Lernunterstützung sein kann, hat BlueJ die Möglichkeit geschaffen, einzelne Java-Befehle auszuführen. Das zugehörige Eingabefenster heißt Code Pad und muss explizit eingeblendet werden. Hierzu wird unter View auf Show Code Pad geklickt. Das Code Pad wird jetzt rechts unten angezeigt. Shaut man erneut unter View nach, sieht man einen Haken vor Show Code Pad. Seite 41 von 157

42 Im Code Pad kann man im Wesentlichen Befehle und Ausdrücke eintippen. Dabei besteht jedes Programm aus einer Folge von Befehlen. Befehle erkennt man daran, dass sie mit einem Semikolon beendet werden. Die folgende Abbildung zeigt, wie eine Variable deklariert und eine Zuweisung ausgeführt wird. Zur Ausführung einer Zeile wird einfach Return gedrückt. Der Hinweistext, beginnend mit Note kann einfach ignoriert werden und weist nur daraufhin, dass im Code Pad jede Variable automatisch einen Wert, hier die Zahl Null erhält. Danach wird versucht, eine zweite Variable zu deklarieren, wobei es hier einen Syntaxfehler gibt. Man kann erahnen, dass die Fehlermeldungen oft nicht sehr aussagekräftig sind. Bei einem Fehler stürzt das Code Pad nicht ab, man kann einfach weitere Befehle eingeben. Durch die Pfeil-Tasten nach oben und nach unten kann man zu vorher eingegebenen Zeilen zurück manövrieren. Diese Zeilen sind dann auch editierbar und werden wieder mit Return ausgeführt. Weiterhin besteht die Möglichkeit in Code Pad Ausdrücke einzugeben, die anschaulich zu einem konkreten Wert ausgewertet werden können. Das Ergebnis oder spätere eine Referenz auf das Ergebnis wird nach dem Drücken der Return-Taste ausgegeben. Ausdrücke enden nicht mit einem Semikolon. Die folgende Abbildung zeigt einige Beispiele. Seite 42 von 157

43 Will man Befehle eingeben, die über mehr als zwei Zeilen gehen, muss man am Zeilenende Shift+Return (also großgeschriebenes Return ) eingeben. Man erkennt an der linken Randmarkierung mit den Punkten, dass man sich im Eingabemodus über mehrere Zeilen befindet. Das folgende Beispiel zeigt auch, dass Werte für Variablen vom Typ String in Anführungsstrichen eingegeben werden. Möchte man alle eingegebenen Variablen löschen, besteht eine Möglichkeit darin, die zur Ausführung benutzte Java Virtual Maschine zu resetten. Dies ist durch einen Rechtsklick auf dem gestreiften Ballen links im Bild und der Auswahl Reset Java Virtual Machine möglich. Seite 43 von 157

44 Den genauen Zustand ees Code Pads kann man nicht abspeichern, es besteht aber die Möglichkeit die Eingaben mit gedrückter linker Maustaste zu markieren, mit Strg+C zu kopieren und dann mit Strg+V in ein Dokument, z. B. eine Word-Datei zu kopieren. Die folgende Abbildung zeigt, dass Ausgaben mit kopiert werden. Alternativ kann man von seinen Ergebnissen ein Bildschirmfoto machen, wie es in Kapitel 10 Installation des Screenshot-Werkzeugs Faststone Capture beschrieben wird. Man kann Eingaben auch ins Code Pad zurück kopieren, wobei man dann natürlich die Ausgaben nicht mitkopieren darf. Die mit Strg+V ins Code Pad kopierten Texte werden insgesamt als ein Befehl angesehen, sollte dieser einen Fehler enthalten, wird er nicht ausgeführt. In der folgeden Abbildung wurde der nachträglich gelb markierte Block mit zwei Befehlen nach Code Pad kopiert und danach der angegebene Ausdruck ausgeführt. Seite 44 von 157

45 4.4 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. 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. Seite 45 von 157

46 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. 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. Seite 46 von 157

47 Es öffnet sich ein Editor, der schon bemerkenswert viel vermeintlichen Programmcode enthält. 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 47 von 157

48 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 aus der letzten Abbildung. Hier ist es nur wichtig, projektweit die einheitliche Formatierung zu Seite 48 von 157

49 nutzen. Um die korrekte Syntax zu ü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 Zeilennummern, 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 49 von 157

50 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 von syntaktisch falschem Programmcode (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 50 von 157

51 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 51 von 157

52 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 52 von 157

53 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 53 von 157

54 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 54 von 157

55 Hier hilft ein Klick auf Edit -> Auto-layout, um zu einer ordentlichen Formatierung zu kommen. Seite 55 von 157

56 Das Ergebnis sieht dann wie folgt aus, man erkennt, dass eventuell überflüssige Leerzeichen manuell entfernt werden müssen. 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 Nutzung eines alternativen Editors (Eclipse) beschrieben wird. 4.5 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. Seite 56 von 157

57 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. 4.6 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. Seite 57 von 157

58 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. Man sieht dann in der unteren Leiste von BlueJ die momentan nutzbaren Objekte, für die der Objektname und die Klasse angegeben werden. Seite 58 von 157

59 4.7 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. Für jede Methode müssen wieder Parameterwerte angegeben werden. Der kleine Pfeil rechts beim Eingabefeld ermöglicht eine Übersicht über bisher bekannte Eingabewerte. Seite 59 von 157

60 Neue Werte können einfach eingetippt und über Ok bestätigt werden. 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. Seite 60 von 157

61 Man erhält ein Ergebnisobjekt, das mit den im folgenden Abschnitt beschriebenen Verfahren auch über Inspect genauer betrachtet werden kann. 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. Seite 61 von 157

62 4.8 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. 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. Seite 62 von 157

63 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. 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 die mehrmalige Nutzung von Close können die Objekt-Ansichten wieder geschlossen werden. Seite 63 von 157

64 4.9 Weitere Nutzung des Code Pad Erste Informationen zum Code Pad stehen im Abschnitt 4.3 Erste Experimente mit dem Code Pad. Es sei daran erinnert, 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 auch einfache Java-Anweisungen mit Methodenaufrufen auf Objekten aus der Objekt-Leiste eingetippt werden. Seite 64 von 157

65 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. Man beachte, dass hinter der Zeile mit new kein Semikolon steht, es handelt sich dadurch um einen Ausdruck, der ausgewertet wird. Seite 65 von 157

66 Dieses Objekt kann jetzt mit gedrückter linker Maustaste in den Bereich mit den Objekten links-unten in die Objekt-Leiste von 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. Der Variablenname aus dem Code Pad wird leider Seite 66 von 157

67 nicht übernommen, da es nicht sichergestellt ist, dass das Objekt überhaupt einen Namen hat, was beim Ergebnis eines Ausdrucks, wie im vorherigen Fall nicht der Fall sein muss. 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. Seite 67 von 157

68 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 68 von 157

69 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-Return 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+return wieder zu einem längeren Befehl zusammengesetzt werden. Seite 69 von 157

70 4.10 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 auch dort 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. Die Inspektion zeigt, dass der Ansatz erfolgreich war. Seite 70 von 157

71 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. Es handelt sich wieder um einen Ausdruck. Die Zeile mit dem Semikolon wird als Befehl aufgefasst. Dieser Aufruf der Methode ist syntaktisch korrekt, da in der Zeile keine Zuweisung an eine Variable stattfindet, wird das Ergebnis einfach ignoriert. Seite 71 von 157

72 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 72 von 157

73 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 73 von 157

74 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 Return abschließen. Seite 74 von 157

75 Nach der Eingabe wird die Rückgabe der Methode als untersuchbarer Wert ausgegeben. Im aktuellen Fall ist es ein einfacher Integer-Wert. Der mit ausgegebene Kommentar kann ignoriert werden. Nun wird eine Methode aufgerufen, die ein Objekt, hier einen String zurückliefert. Seite 75 von 157

76 Die Eingabe erfolgt wieder über das Terminal Window. Sollten alte Eingaben stören, können diese vorher über Options -> Clear gelöscht werden. Möchte man, dass bei jedem Methodenaufruf das Ausgabefenster gelöscht wird, muss Clear screen at method call angeklickt werden. Erwartet man sehr lange Ausgaben muss man Unilimited Buffering auswählen. Ohne Löschen wird jetzt ein String eingegeben, der auch Leerzeichen enthalten kann. Seite 76 von 157

77 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 77 von 157

78 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 78 von 157

79 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 79 von 157

80 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 80 von 157

81 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. Ein laufendes Programm erkennt man daran, dass der Balken auf der linken Seite rote, sich bewegende Streifen hat. Seite 81 von 157

82 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. Zeichen Unicode Ä, ä \u00c4, \u00e4 Ö, ö \u00d6, \u00f6 Ü, ü \u00dc, \u00fc ß \u00df Seite 82 von 157

83 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 83 von 157

84 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 84 von 157

85 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 85 von 157

86 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(){ int 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: "); int mat = this.io.leseinteger(); this.io.ausgeben("name: "); String name = this.io.lesestring(); this.io.ausgeben("fach: "); String fach = this.io.lesestring(); Seite 86 von 157

87 } if(matrikelnummerexistiert(mat)){ 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(int mat){ Boolean ergebnis = false; Student tmp = studentsuchen(mat); if(tmp!= null){ ergebnis = true; } return ergebnis; } public void studentsuchen(){ this.io.ausgeben("welche Matrikelnummer? "); int 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(int 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 87 von 157

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

89 Seite 89 von 157

90 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 und behauptet, dass es schon einen Studenten mit diese Matrikelnummer gibt.. Seite 90 von 157

91 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. Grundsätzlich kann man durchaus mehrere Breakpoints setzen, dass Programm unrtbricht dann, wenn der erste Breakpoint erreicht wird. Seite 91 von 157

92 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. 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 92 von 157

93 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. Die gerade laufende Methode steht dabei immer oben. Durch einen Klick auf die aufrufende Methode, wird dies auch im Editor markiert. 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 eine Variable. Seite 93 von 157

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

95 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 95 von 157

96 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. Das Fenster kann einfach geschlossen und das Programm neu übersetzt werden. Der Breakpoint sollte vor der nächsten Ausführung gelöscht werden. Seite 96 von 157

97 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 97 von 157

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

99 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 99 von 157

100 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 und beinhalten den Namen der zu testenden Methode. Seite 100 von 157

101 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 101 von 157

102 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 102 von 157

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

104 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 104 von 157

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

106 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 106 von 157

107 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 107 von 157

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

109 Dann wird unten auf Next> geklickt. Seite 109 von 157

110 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 110 von 157

111 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 111 von 157

112 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 112 von 157

113 Ä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 113 von 157

114 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 114 von 157

115 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 115 von 157

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

117 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 117 von 157

118 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 118 von 157

119 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 119 von 157

120 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 120 von 157

121 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 121 von 157

122 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 122 von 157

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

124 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 124 von 157

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

126 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 126 von 157

127 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 127 von 157

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

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

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

131 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 131 von 157

132 10.3 Erste Schritte in der Nutzung Der Start des Programms erfolgt z. B. durch einen Doppelklick auf das Icon oder über den Eintrag im Startmenü. Seite 132 von 157

133 Die wesentlichen Knöpfe für verschiedene Snapshot-Varianten sind selbsterklärend. (Da sich das Werkzeug nicht selbst fotografieren kann, es blendet sich sinnvollerweise für Fotos aus, wurde ein virueller Rechner fotografiert.) Erster Knopf von links (aktuelles Fenster): Zweiter Knopf von links (Fenster ist auswählbar): Dritter Knopf von links (beliebiges Rechteck): Vierter Knopf von links (beliebige Form): Fünfter Knopf von links (gesamter Bildschirm): Sechster Knopf von links (Fenster auch mit nicht sichtbaren Bereich): Seite 133 von 157

134 Siebter Knopf zum Herunterklappen ermöglicht die Auswahl, wo sich das Bild befinden soll. Die Standard-Einstellung zum Editor kann so gelassen werden. Der Knopf ganz rechts führt zu den Einstellungsmöglichkeiten. Ohne weitere Einstellungen, wird diese Funktionalität sofort ausgeführt. Um dieses zu ändern, muss der Settings -Knopf ganz rechts gedrückt und Settings gewählt werden. Von den vielen Einstellungsmöglichkeiten sind folgende besonders wichtig, die man bei der Arbeit ändern sollte. Seite 134 von 157

135 1: Es sollte ein Haken gesetzt werden bei Include Mouse in Captured Image, damit man den Mauszeigern auch in den Bildern sieht. 2: Mit Delay before Capture kann man angeben, wie lange nach dem Drücken eines Foto- Knopfes gewartet wird, bis das Foto gemacht wird. Dies ist sinnvoll, wenn man zuerst die Maus in Position bringen möchte, wenn z. B. aufgeklappte Menüs fotografiert werden sollen. Erfahrungsgemäß ist ein Wert von 4 Sekunden sinnvoll. Alle Einstellungen müssen über den OK -Knopf rechts-unten übernommen werden. 1 2 Möchte man dann einen Teilbereich des Bildschrims fotografieren, drückt man auf einen der Knöpfe, meist ist der rechteckige Ausschnitt sehr sinnvoll. Danach verschwindet das FastStone Editor -Fenster und man kann die zu fotografierende Situation einstellen. Bei einem Rechteck-Bild kann man dann mit zwei Ecken und einfachen Mausklicks bestimmen, welcher Bereich fotografiert werden soll. Dies soll im Beispiel ein einfaches Stück des aufgeklappten Start-Menü in Windows XP sein. Man erkennt im folgenden Bild, dass eine Lupe genutzt wird, damit man Pixel-genau bestimmen kann, wo die Eckpunkte des gewünschten Ausschnitts liegen. Seite 135 von 157

136 Nachdem man beide Punkte gewählt hat, öffnet sich ein einfacher graphischer Editor, der im Wesentlichen selbsterklärend ist. Meist will man einfach das Foto in ein Dokument kopieren, hier genügt der klassische Guttenberg-Griff, mit Strg+A alles markieren, mit Strg+C das Bild kopieren und mit Strg+V im gewünschten Dokument einfügen. Man kann das Bild so natürlich auch in komportablere Bildbearbeitungsprogramme kopieren. Seite 136 von 157

137 Seite 137 von 157

138 11 Nutzung des Screenshot-Werkzeugs Shotty Allgemeine Informationen, warum und wozu Screenshot-Werkzeuge hilfreich sein können, stehen im Kapitel 10 Installation des Screenshot-Werkzeugs Faststone Capture. In diesem Kapitel wird eine Alternative vorgestellt, die ggfls. auf den Hochschulrechnern installiert ist Starten Das Programm Shotty findet man recht einfach unter den installierten Programmen, man kann z. B. in dem im folgenden Bild dargestellten Pfad suchen Konfigurieren Nach dem Programmstart befindet sich rechts unten ein Icon zum laufenden Programm (hier das Icon ganz links in der Liste). Mit einem Rechtsklick auf diesem Icon gelangt man zu einem Konfigurationsmenü, aus dem der Punkt Erweiterte Einstellungen ausgewählt wird. Seite 138 von 157

139 Von den verschiedenen Einstellungsmöglichkeiten ist besonders die Möglichkeit das Erstellen eines Fotos zu verzögern interessant, die hier von 10 auf 5 Sekunden verändert wurde. Die Übernahme der Änderungen erfolgt mit OK rechts-unten. Seite 139 von 157

140 11.3 Nutzung Zur Programmnutzung wird ein Linksklick auf dem Icon in der Programmleiste ausgeführt. Danach stehen drei Varianten zur Auswahl, mit denen der gesamte Bildschrim, ein Ausschnitt oder ein einzelnes Fenster fotografiert werden können. Die Möglichkeiten werden durch einen einfachen Linksklick ausgewählt. Hält man zusätzlich die Strg-Taste gedrückt, wird die eingestellte Verzögerung bis zum Foto berücksichtigt. Wählt man Bereich kann man dann mit gedrückter Maustaste einen Bereich auswählen. (Sollte man nur klicken, besteht keine Möglichkeit einen Bildschirmausschnitt zu wählen.) Danach öffnet sich ein einfacher Editor, in dem man das Bild mit Strg+C oder dem Kopieren -Knopf halb-links-oben in die Zwischenablage kopieren und mit Strg+V z. B. in eine Textverarbeitung kopieren kann. Seite 140 von 157

141 12 Nutzung von Processing in BlueJ Dieses Kapitel zeigt, wie man Processing-Projekte in BlueJ entwickeln kann. Processing ( ist hervorragend geeignet, unterschiedlichste Dinge zu visualisieren und Interaktionen zu ermöglichen. Da Processing hauptsächlich in Java entwickelt ist, kann man wesentliche Teile davon auch in BlueJ nutzen. In diesem Kapitel wird angenommen, dass erste Kenntnisse über Processing vorliegen, die man sonst leicht über die intuitiven Einführungsbeispiele der Web-Seite gewinnen kann. Wesentliche Ideen dieses Kapitels sind entnommen. Das folgende Projekt zeigt die grundsätzlichen Möglichkeiten der Integration, die zum weiteren Experimentieren anregen sollen. Vor dem Start sollte man wissen, wo man Processing installiert hat, hier C:\Programme\processing-2.0b Einmalige Einrichtung der Nutzungsmöglichkeit Zunächst wird in BlueJ ein neues Projekt mit Namen ErstesProcessing angelegt. Nun sollen wichtige Teile der Processing-Klassen, die in einer jar-datei gepackt sind, für das Projekt zugänglich gemacht werden. Dabei wird der folgende Schritt nur einmal mit einem Projekt gemacht und muss für weitere Projekte nicht wiederholt werden. Es wird ein Klick auf Tools und dann Preferences gemacht. Seite 141 von 157

142 Es wird oben der Reiter Libraries ausgewählt und Add angeklickt. Im sich öffnen Dateibrowser steuert man z. B. zunächst über einen Klick auf Arbeitsplatz am linken Rand, zur Processing-Installation, dort in den Ordner core und dann library. Seite 142 von 157

143 Nun klickt man core.jar an und dann auf Öffnen. Der Arbeitsschritt wird über Ok abgeschlossen. Seite 143 von 157

144 Die nachfolgende Meldung liest man, wird sie danach umsetzen und klickt auf Ok. Der geforderte Restart ist z.b. über einen Rechtsklick auf dem gestreiften Balken möglich. Seite 144 von 157

145 Durch das gezeigte Importieren steht die Grundfunktionalität von Processing zur Verfügung. Für komplexere Programme müssen gegebenenfalls weitere jar-bibliotheken mit eingebunden werden Programmieren mit Processing Es wird in einem Projekt eine normale Java-Klasse angelegt, in der Processing genutzt werden soll. Die folgende Abbildung zeigt, dass zunächst zwei besondere Schritte ergänzt werden. Zunächst wird hinter dem Klassennamen ein extends PApplet ergänzt, was informell bedeutet, dass unsere Klasse die Klasse PApplet erweitern soll, also man direkt auf alle in PApplet definierten Methoden (im Processing-Sprachgebrauch Funktionen) zugreifen kann. Genauer spricht man von Vererbung. Vor dem Klassennamen wird, wie sonst üblich, das Schlüsselwort public gesetzt, damit andere Objekte Objekte dieser Klasse nutzen können. Weiterhin muss die zentrale Klasse PApplet zugänglich gemacht werden, was durch eine z. B. von der ArrayList bekannte import-zeile vor der Klasse ermöglicht wird. Seite 145 von 157

146 In der Klasse selbst schreibt man wieder seine eigenen Methoden, in denen man auch auf die bekannten Processing-Methoden zugreifen kann. Das folgende Beispiel zeigt eine Mischung aus den zentralen Processing-Methoden init() und draw() sowie selbst geschriebenen Methoden. Alle Methoden werden dabei mit dem Schlüsselwort public eingeleitet. Seite 146 von 157

147 Schaut man sich nach dem Kompilieren das BlueJ-Hauptfenster an, erkennt man, dass die Klasse automatisch als Applet erkannt wird. Zum Starten wird ein Rechtsklick auf der Klasse gemacht und ganz oben Run Applet ausgewählt. Seite 147 von 157

148 Im nächsten Schritt kann man z. B. den als Standard-Browser des Systems eingestellten Browser durch die Auswahl Run Applet in web browser nutzen und auf Ok klicken. Der angebotene Appletviewer macht leider häufiger Probleme. Im sich öffnenden Browser-Fenster kann man dann mit gedrückter Maus-Taste malen. Seite 148 von 157

149 Das Programm wird durch Schließen des Browsers beendet. Generell kann man mit Applets sehr schnell schöne Skizzen erstellen, allerdings wird die Ausführung von Java im Browser oft kritisch gesehen, da es häufiger Sicherheitsprobleme mit Applets gab und auch die Integration mit anderen HTML-Elementen nur sehr eingeschränkt ist. Es sei betont, dass Java selber, wenn es nicht in einem Browser läuft als sehr sicher eingestuft wird, ein Großteil aller Web-Programme im kommerziellen Bereich ist in Java realisiert. Seite 149 von 157

150 Processing unterstützt zum Glück auch den Aufruf des Programms ohne Browser. Dazu wird im Programm folgende sehr merkwürdige Methode ergänzt. Für die eigentliche Nutzung reicht es aus, die Methode abzutippen und den Klassennamen in den Anführungsstrichen zu ersetzen. Genauer muss in Java festgelegt werden, was zum Programmstart passiert, was sonst BlueJ-Nutzer selber durch das Erzeugen von Objekten und das Aufrufen von Methoden festlegen. Hierzu wird eine Methode main genutzt, die public sein und als Parameterliste immer den Inhalt (String[] s) haben muss, wobei der Name des Parameters anders lauten kann. Als Spezialfall beim Methodenaufruf im Programm wird hier der Inhalt des Arrays unmittelbar angegeben, eine spannende Möglichkeit, die aber Programmieranfänger vom Verständnis her überfordern kann. Weiterhin wird die Methode als static markiert, wodurch sie zur Klassenmethode wird, so dass man die Methode ausführen kann, ohne dass ein Objekt erzeugt werden muss. Zur Ausführung wird wieder ein Rechtsklick auf der Klasse gemacht, jetzt aber main({}) ausgewählt. Im nachfolgenden Fenster wird nur Ok geklickt. Seite 150 von 157

151 Das Programm startet in der Mitte des Bildschirms. In der linken-oberen und der linkenunteren Ecke werden stop -Knöpfe eingeblendet, so dass man mit einem Klick das Programm beenden kann. In einzelnen Szenarien funktionierte nur der untere Knopf. Applikation, eigentlich in der Mitte des Bildschirms stop-knopf links-unten Das Programm zusammengefasst: import processing.core.papplet; public class ErstesProcessing extends PApplet{ int xgroesse = 200; int ygroesse = 200; int farbe = 110; Seite 151 von 157

152 public void setfarbe(int farbe){ this.farbe = farbe; } public int getfarbe(){ return this.farbe; } public void setup() { size(this.xgroesse,this.ygroesse); background(getfarbe()); } public void draw() { stroke(0); if (mousepressed) { line(mousex,mousey,pmousex,pmousey); } } } public static void main(string args[]) { PApplet.main(new String[] { "--present", "ErstesProcessing" }); } 12.3 Besonderheit beim Umgang mit float-werten Ändert man das vorherige Programm leicht in der Methode draw() ab und nutzt keine ganzen Zahlen für die Methode stroke, gibt es in Processing keine Probleme. Seite 152 von 157

153 Wählt man den gleichen Ansatz in BlueJ, kommt es zu Problemen. Seite 153 von 157

154 Der Hintergrund ist, dass eine Zahl 5.1 in Java automatisch ein Wert vom Typ double ist, der nicht in einen von der Methode erwarteten float-wert umgewandelt wird. Diesen Schritt bekommt die Processing-Umgebung ohne weitere Hilfe hin. Was in Java ohne Probleme klappt, ist die Umwandlung einer ganzen Zahl (int) in einen float-wert. Will man in Java einen float-wert hinschreiben, muss hinter der Zahl ein kleines (oder großes f ) stehen. Sollte es sich um eine Variable vom Typ double handeln, kann sie durch das Voranstellen von (float), einem sogenannten Typ-Cast, umgewandelt werden Processing in weiteren Klassen nutzen In größeren Projekten werden für zu verwaltende Objekte eigene Klassen geschrieben. Diese Klassen sollten häufiger auch mit Hilfe von Processing visualisiert werden. Das Problem ist Seite 154 von 157

155 dann, dass diese Objekte auf das Processing-Objekt zugreifen können müssen, was durch einen direkten Methodenaufruf nicht machbar ist. Als Beispiel sollen Spielkarten dienen, die sich selber an einer vorgegebenen Position darstellen sollen. Der Trick ist, dass das Processing-Objekt als Parameter mit übergeben wird. Im Programmcode ist dies ein Objekt vom Typ Spiel, der PApplet erweitert. Alternativ könnte hier auch direkt PApplet als Typ stehen. Man sieht, dass in darstellen() die bekannten Processing-Methoden mit dem Parameter spiel genutzt werden. public class Karte{ private String farbe; private String wert; public Karte(String farbe, String wert){ this.farbe = farbe; this.wert = wert; } } public void darstellen(spiel spiel, int xpos, int ypos){ spiel.nofill(); spiel.stroke(0); spiel.rect(xpos, ypos, 45, 72, 5); spiel.stroke(110); spiel.fill(0, 102, 153); spiel.text(farbe,xpos+2,ypos+15); spiel.text(wert,xpos+2,ypos+30); } In der Klasse Spiel muss zum Aufruf von darstellen() bei der Karte ein Objekt vom Typ Spiel übergeben werden. Da das Objekt selbst diesen Typ hat und die Zeichenfläche beinhaltet, übergibt sich das Objekt selbst mit this. import processing.core.papplet; public class Spiel extends PApplet{ private int xgroesse = 200; private int ygroesse = 200; private Karte k1; private Karte k2; private Karte k3; public void setup() { size(this.xgroesse,this.ygroesse){ this.k1 = new Karte("Pik", "Ass"); Seite 155 von 157