Nutzungshinweise für BlueJ - hs-osnabrueck.de

Seite 1 von 157

Nutzungshinweise für BlueJ

Thema: Nutzung der Entwicklungsumgebung BlueJ

Autoren: Prof. Dr. Stephan Kleuker

Version / Datum: 1.5 / 26.10.2012

Empfänger: Teilnehmer der Lehrveranstaltungen im Bereich Programmierung des Studiengangs Media & Interaction-Design

1 Vorbemerkungen ................................................................................................................ 3

2 Installation von Java ........................................................................................................... 6

3 Installation von BlueJ ....................................................................................................... 22

4 Erste Nutzung von BlueJ .................................................................................................. 31

4.1 Anlegen eines Projektes ........................................................................................... 31

4.2 Laden eines existierenden Projekts .......................................................................... 38

4.3 Erste Experimente mit dem Code Pad ...................................................................... 40

4.4 Erstellung einer ersten Klasse .................................................................................. 45

4.5 Kompilierung einer Klasse ....................................................................................... 56

4.6 Erstellung eines Objektes einer Klasse .................................................................... 57

4.7 Ausführung von Exemplarmethoden ....................................................................... 59

4.8 Genaue Analyse eines Objekts ................................................................................. 62

4.9 Weitere Nutzung des Code Pad ................................................................................ 64

4.10 Weitere Nutzung von Objekten ................................................................................ 70

5 Arbeiten mit mehreren Klassen in BlueJ .......................................................................... 72

5.1 Laden externer Klassen ............................................................................................ 72

5.2 Nutzung der Eingabeklasse ...................................................................................... 74

5.3 Ein einfaches Programm mit Nutzung einer Sammlung .......................................... 79

6 Nutzung des Debuggers ................................................................................................... 90

7 Testen ............................................................................................................................... 97

7.1 Erzeugen einer Testklasse ........................................................................................ 97

7.2 Ausführung von Tests ............................................................................................ 100

8 Nutzung eines alternativen Editors (Eclipse) ................................................................. 106

8.1 Bearbeitung von BlueJ-Code aus Eclipse heraus ................................................... 106

8.2 Eclipse referenziert BlueJ-Dateien ......................................................................... 118

9 Nutzung von nicht in BlueJ erstellten Projekten ............................................................ 122

10 Installation des Screenshot-Werkzeugs Faststone Capture ............................................ 126

Seite 2 von 157


10.1 Herunterladen und Installieren ............................................................................... 126

10.2 Portable Alternative ................................................................................................ 131

10.3 Erste Schritte in der Nutzung ................................................................................. 132

11 Nutzung des Screenshot-Werkzeugs Shotty .................................................................. 138

11.1 Starten ..................................................................................................................... 138

11.2 Konfigurieren ......................................................................................................... 138

11.3 Nutzung .................................................................................................................. 140

12 Nutzung von Processing in BlueJ................................................................................... 141

12.1 Einmalige Einrichtung der Nutzungsmöglichkeit .................................................. 141

12.2 Programmieren mit Processing .............................................................................. 145

12.3 Besonderheit beim Umgang mit float-Werten ....................................................... 152

12.4 Processing in weiteren Klasen nutzen .................................................................... 154

Seite 3 von 157


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 http://www.bluej.org/doc/documentation.html 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 4 von 157


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


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


2 Installation von Java

Java wird direkt von der Sun-Seite http://www.oracle.com/technetwork/java/index.html 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 http://www.oracle.com/technetwork/java/javase/downloads/index.html 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 7 von 157


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


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

Seite 9 von 157


Bei der folgenden Meldung hat man vergessen, oben die Lizenzbedingungen zu bestätigen.

Dann kann der Download stattfinden.

Seite 10 von 157


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


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


Die Installation benötigt Zeit.

Eventuell wird man aufgefordert, den Installationsort für die JRE anzugeben. Der Vorschlag wird hier übernommen.

Seite 13 von 157


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

Seite 14 von 157


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


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


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


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


Hier wählt man den Punkt „Erweiterte Systemeinstellungen“ mit einem einfachen Klick aus.

Man nutzt den Reiter „Erweitert“ und klickt unten auf „Umgebungsvariablen“.

Seite 19 von 157


Administratoren des Systems nutzen den Knopf „Neu...“ unter Systemvariablen, andere Nutzer den Knopf „Neu…“ unter Benutzervariablen.

Seite 20 von 157


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


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


3 Installation von BlueJ

Das Programm kann unter http://www.bluej.org/download/download.html heruntergeladen werden.

Der Link zur Datei wird angeklickt und die zugehörige Datei heruntergeladen.

Seite 23 von 157


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


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

Seite 25 von 157


Die Startmeldung wird gelesen und mit „Next“ der Installationsprozess fortgesetzt.

Seite 26 von 157


Danach wird geprüft, ob eine korrekte Java-Installation vorliegt, dies kann mit „Next“ bestätigt werden.

Seite 27 von 157


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


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


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


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

Seite 31 von 157


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


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

Seite 33 von 157


Danach zeigt sich eine recht einfache, aufgeräumte Entwicklungsumgebung.

Seite 34 von 157


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


Hier hilft ein Klick auf „Edit -> Auto-layout“, um zu einer ordentlichen Formatierung zu kommen.

Seite 56 von 157


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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 Samm lung

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


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


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


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 http://javawiki.sowas.com/doku.php?id=java:unicode dazu verlinken.

Zeichen Unicode ------------------------------ Ä, ä \u00c4, \u00e4 Ö, ö \u00d6, \u00f6 Ü, ü \u00dc, \u00fc ß \u00df

Seite 83 von 157


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.

1 2 3

Seite 84 von 157


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


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


recht drastischer Schritt und sollte nur genutzt werden, wenn keine anderen Möglichkeiten bestehen

Das resultierende Programm sieht dann wie folgt aus. /** * @author S. Kleuker * @version 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 87 von 157


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


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

Seite 89 von 157


Seite 90 von 157


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


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


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


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


Im Debugger wird jetzt „Step Into“ aufgerufen. Was man an der „Call Sequence“, den neuen lokalen Variablen und der jetzt markierten Zeile erkennt.

Seite 95 von 157


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


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


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


Es entsteht eine neue Klasse, die z. B. mit einem Doppelklick geöffnet wird.

Die Klasse ist bereits mit einigem Programmcode gefüllt.

Seite 99 von 157


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


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 mit @Test 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 101 von 157


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


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


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

Seite 104 von 157


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 mit @Before annotierte Methode, dann der Test und dann die mit @After 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 dummy; @Before public void setUp(){ sv = new Studentenverwaltung(); dummy = new Student(42,"Marvin","ROB"); } @Test public void testMatrikelnummerExistiertNicht(){ Assert.assertTrue(!sv.matrikelnummerExistiert(42)); } @Test public void testMatrikelnummerExistiert(){ sv.studentHinzufuegen(dummy); Assert.assertTrue(sv.matrikelnummerExistiert(42)); } @Test public void testStudentExistiertNicht(){ Assert.assertTrue(sv.studentSuchen(42)==null); }

Seite 105 von 157


@Test public void testStudentExistiert(){ sv.studentHinzufuegen(dummy); Assert.assertTrue(sv.studentSuchen(42) == dummy); } }

Seite 106 von 157


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


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


Hier wird das genaue Projektverzeichnis ausgewählt und mit „OK“ bestätigt.

Seite 109 von 157


Dann wird unten auf „Next>“ geklickt.

Seite 110 von 157


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


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


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


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


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


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


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

Seite 117 von 157


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


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


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


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


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


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


Man erhält dann die Projektstruktur in BlueJ nachgebildet.

Zu beachten ist, dass das ursprüngliche Projekt um BlueJ-Informationen ergänzt wird.

Seite 124 von 157


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


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

Seite 126 von 157


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.

10.1 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 http://www.chip.de/downloads/FastStone-Capture-Letzte-Freeware-Version_20749866.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 127 von 157


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


Die Installation wird durch einen Doppelklick auf der heruntergeladenen Datei gestartet.

Das Startfenster wird mit „Next>“ verlassen.

Seite 129 von 157


Die Lizenzbedingungen gelesen (u. a. Freeware für educational use) und mit „I Agree“ bestätigt.

Seite 130 von 157


Danach kann das Installationsverzeichnis gewählt werden und es wird „Install“ gedrückt.

Die Installation wird mit „Finish“ abgeschlossen.

Seite 131 von 157


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. http://www.portablefreeware.com/?id=775. Dort den Download-Link benutzen.

Seite 132 von 157


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


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


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


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.

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.

1

2

Seite 136 von 157


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


Seite 138 von 157


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.

11.1 Starten

Das Programm Shotty findet man recht einfach unter den installierten Programmen, man kann z. B. in dem im folgenden Bild dargestellten Pfad suchen.

11.2 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 139 von 157


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


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


12 Nutzung von Processing in BlueJ

Dieses Kapitel zeigt, wie man Processing-Projekte in BlueJ entwickeln kann. Processing (http://processing.org/) 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 http://processing.org/learning/eclipse/ 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.0b3.

12.1 Einmalige Einrichtung der Nutzungsmöglichkei t

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


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


Nun klickt man core.jar an und dann auf „Öffnen“.

Der Arbeitsschritt wird über „Ok“ abgeschlossen.

Seite 144 von 157


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


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.

12.2 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 146 von 157


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


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


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


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


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


Das Programm startet in der Mitte des Bildschirms. In der linken-oberen und der linken-unteren Ecke werden „stop“-Knöpfe eingeblendet, so dass man mit einem Klick das Programm beenden kann. In einzelnen Szenarien funktionierte nur der untere Knopf.

Das Programm zusammengefasst: import processing.core.PApplet; public class ErstesProcessing extends PApplet{ int xGroesse = 200; int yGroesse = 200; int farbe = 110;

Applikation, eigentlich in der

Mitte des Bildschirms

stop-Knopf links-unten

Seite 152 von 157


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


Wählt man den gleichen Ansatz in BlueJ, kommt es zu Problemen.

Seite 154 von 157


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.

12.4 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 155 von 157


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


this.k2 = new Karte("Karo", "Sieben"); this.k3 = new Karte("Herz", "Dame"); } public void draw() { background(255,204,0); this.k1.darstellen(this,20,20); this.k2.darstellen(this,70,30); this.k3.darstellen(this,120,20); } public static void main(String args[]) { PApplet.main(new String[] { "--present", "Spiel" }); } }

Die Programmausgabe sieht wie folgt aus.

Man kann auch mit dem weitergegebenen Objekt auf die Processing-Variablen zugreifen. Dazu wird in Karte die Methode darstellen leicht verändert und direkt auf die Boolesche Variable mousePressed zugegriffen.

public void darstellen(Spiel spiel, int xpos, int ypos){ if(spiel.mousePressed == true){ 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); }

Bei nicht gedrückter Maustaste sieht das Ergebnis wie folgt aus. Ist die Maustaste gedrückt, sieht das Ergebnis wie vorher aus.

Seite 157 von 157


Weitere Informationen zu den Methoden und Variablen von PApplet findet man unter http://processing.org/reference/ und teilweise auch http://processing.googlecode.com/svn/trunk/processing/build/javadoc/core/processing/core/PApplet.html

Man beachte, dass der Debugger von BlueJ zusammen mit Processing nicht genutzt werden kann. Weiterhin ist ein Zugriff auf ein Ein- und Ausgabekonsole, z. B. mit der Klasse EinUndAusgabe.java nicht möglich.

Nutzungshinweise für BlueJ - hs-osnabrueck.de

Documents

Transcript of Nutzungshinweise für BlueJ - hs-osnabrueck.de