Das Java Leitprogramm

Greenfoot und Java
Kretschmer
Stand: 20. Oktober 2010
1

Inhaltsverzeichnis
1. Einleitung 5
1.1. Was ist Greenfoot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2. Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1. Die Welt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2. Das Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.3. Die Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.4. Das Menü . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2. Kapitel I - Objekt Oriented Programming 7
2.1. OOP - Die Idee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.1. Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.2. Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2. Ein Szenario önen und starten . . . . . . . . . . . . . . . . . . . . . . . 9
2.3. Was können Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.1. Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.2. Aufgabe zum Thema Methoden . . . . . . . . . . . . . . . . . . 12
2.3.3. Variablen und Konstanten . . . . . . . . . . . . . . . . . . . . . . 13
2.4. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3. Kapitel II - Das erste Szenario 16
3.1. Steuern des Wombat per Hand . . . . . . . . . . . . . . . . . . . . . . . 17
3.2. Automatisches Steuern des Wombat - Die Methode act() . . . . . . . . 19
3.2.1. Der erste Quellcode-Fetzen . . . . . . . . . . . . . . . . . . . . . 20
3.3. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4. Exkursion I - FlowCharts 22
4.1. Grundlegende Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.1. Start / Stop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.2. Eingabe und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.3. Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.1.4. Entscheidungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.1.5. Unterprogramme / Blöcke . . . . . . . . . . . . . . . . . . . . . . 25
4.1.6. Ablaufpfeile und Schleifen . . . . . . . . . . . . . . . . . . . . . . 25
4.2. Belegungstabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.3. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.4. Eigene FlowCharts erstellen . . . . . . . . . . . . . . . . . . . . . . . . . 29
5. Kapitel III - Erste Schritte im Quelltext 30
5.1. Die Methode act() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.1.1. Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.1.2. Einrückung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2

5.1.3. Was macht der Code - Schrittweises Durchgehen . . . . . . . . . 34
5.1.4. Die If-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.5. Code und FlowChart . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.1.6. Den Wombat automatisch positionieren . . . . . . . . . . . . . . 36
5.1.7. Man fängt am Ende an - Eine kleine Hilfe . . . . . . . . . . . . . 37
5.2. Flags - Merker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.4. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6. Kapitel IV - Hungrige Wombats 40
6.1. Erweiterung unseres Programms . . . . . . . . . . . . . . . . . . . . . . 41
6.2. Was ist ein Algorithmus überhaupt? . . . . . . . . . . . . . . . . . . . . 41
6.2.1. Denition - Algorithmus . . . . . . . . . . . . . . . . . . . . . . . 41
6.2.2. Beispiele zur Darstellung . . . . . . . . . . . . . . . . . . . . . . 42
6.2.3. Umsetzen der eigenen Idee . . . . . . . . . . . . . . . . . . . . . 43
6.2.4. FlowChart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2.5. Implementation in der act() Methode . . . . . . . . . . . . . . . 43
6.3. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.4. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
7. Kapitel V - Was uns Klassendiagramme alles sagen 45
7.1. Die Klassensignatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7.2. Klassendiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7.2.1. Eine einzelne Klasse beschreiben . . . . . . . . . . . . . . . . . . 47
7.2.2. Zusammenhänge . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7.3. Die Java API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7.4. Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.5. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.6. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8. Kapitel VI - Vererbung und Interfaces 52
8.1. Die Vererbungsidee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.1.1. Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.1.2. Vererbung in Greenfoot . . . . . . . . . . . . . . . . . . . . . . . 56
8.1.3. Vererbung in Klassendiagrammen . . . . . . . . . . . . . . . . . . 57
8.2. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8.2.1. Interfaces in UML . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.3. Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
8.4. instanceof - Exkursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.5. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
8.6. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9. Kapitel VII - Weitere Fähigkeiten von Greenfoot 65
9.1. Bilder austauschen mit setImage() . . . . . . . . . . . . . . . . . . . . . 66
9.2. Neue Objekte in die Welt einfügen . . . . . . . . . . . . . . . . . . . . . 66
3

9.3. Hast du Töne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
9.4. Input und Output per Tastatur . . . . . . . . . . . . . . . . . . . . . . . 67
9.4.1. Andauerndes Drücken . . . . . . . . . . . . . . . . . . . . . . . . 67
9.4.2. Kurzes Antippen . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
9.4.3. Ein weiters Beispiel (Funken) . . . . . . . . . . . . . . . . . . . . 68
9.5. Input und Output per Maus . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.6. Zufall und Zufallswerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.7. Und wie nun weiter? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.Ende 71
10.1. Fragebogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.1.1. Benutzbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.1.2. Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.1.3. Lernzuwachs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
10.1.4. Verbesserungsvorschläge und Ideen . . . . . . . . . . . . . . . . . 72
11.Ein Dankeschön 73
A. Installation von Java und Greenfoot 74
A.1. Java installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
A.2. Greenfoot installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
A.3. Erweiterte Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
B. Benutzung des Leitprogramms 75
B.1. Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
B.1.1. Arbeitsanleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
B.1.2. Zeichenerklärung: . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
C. Verzeichnisse 79
C.1. Bilderverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
C.2. Listingverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4

1. Einleitung
Wir wollen in diesem Schuljahr eine neue Programmiersprache (Java) 1 kennenlernen
und am Anfang die Entwicklungsumgebung Greenfoot 2 benutzen. Eine Anleitung zur
Installation gibt es im Anhang A. Die Installation von Java und Greenfoot ist die erste
Hausaufgabe. Bei Fragen kontaktiert mich bitte per E-Mail (D@vid-Kretschmer.de).
Diese Anleitung ist als Leitprogramm gedacht. Wie dieses zu benutzen ist, wird im
Anhang B erläutert.
1.1. Was ist Greenfoot
Greenfoot ist eine grasche Programmierschnittstelle, die sehr gut für den Einstieg in
Java geeignet ist, da sie eine direkte Interaktion mit Objekten ermöglicht und Aktionen
der Objekte grasch sichtbar gemacht werden können.
Sie hilft dir, schnell die wichtigsten Konzepte von Java, angefangen bei Objekten und
Klassen bis hin zur Vererbung zu verstehen.
Beginnen wir zuerst einmal mit einer Übersicht über den Editor von Greenfoot.
1 java.sun.com
2 www.greenfoot.org
5

1.2. Editor
1.2.1. Die Welt
Der groÿte Bereich wird
Welt genannt. Dies ist
der Bereich, in dem
die Objekte abgelegt
wedern und die Ausgabe
des Programms
als Bewegung der Objekte
sichtbar gemacht
wird. Im ersten Szenario
ist die Welt sandfarben
und mit Gitterlinien
durchzogen, sie kann
aber auch völlig anders
aussehen.
1.2.2. Das
Klassendiagramm
Der rechte Teil des
Fensters enthält eine
Art Baum mit Kästchen
und Pfeilen. Dieser wird
Klassendiagramm genannt.
Was sich genau
dahinter verbirgt, werden
wir später besprechen.
Abbildung 1: Greenfoot - So sieht es aus ...
1.2.3. Die Steuerung
Die Buttons ACT, RUN und RESET und der Schieberegler für die Geschwindigkeit
ganz unten dienen zur Programmsteuerung. Hier kann man die Durchläufe eines Programmes
schrittweise oder als automatische Sequenz ablaufen lassen.
1.2.4. Das Menü
Wie gewohnt gibt es hier Einträge zum Önen und Schlieÿen von Szenarios (Ein
Szenario ist eine Sammlung von Programmteilen, so genannten Klassen), einen Menübereich
zur Steuerung (ähnlich der Steuerungsleiste am unteren Fensterrand) und der
Greenfoot-Hilfe.
6

2. Kapitel I - Objekt Oriented Programming
Übersicht
Das ist das erste Kapitel zu Java und Greenfoot. Es werden Grundlagen im Umgang
mit Greenfoot gelegt und erste Begriichkeiten geklärt. Die hier eingeführten
Bezeichnungen sind extrem Wichtig, da sie als Grundlagen für die gesamte
Obersutfeninformatik gebraucht werden.
Lernziele
In diesem Kapitel wirst du die folgenden Begrie kennenlernen:
• Objekt
• Klasse
• Instanz
• Methode
• Rückgabetyp
• Sichtbarkeit
• Variable
• primitive Datentypen
7

2.1. OOP - Die Idee
Information
Die Grundidee der OOP ist es, dass es nicht mehr nur ein groÿes Programm gibt, dass
alles kann und einfach nur abgearbeitet wird. Vielmehr gibt es nach dem Starten eines
Java-Programms eine Vielzahl von Ateuren, sogenannten Objekten, die alle eigene
Eigenschaften haben, welche in Klassen beschrieben werden. Das klingt zunächst sehr
kompliziert, ist im Grunde aber genau das, was wir tagtäglich erleben. Stellt euch vor,
in diesem Klassenraum läuft ein Programm ab. Der Raum, unser erstes Objekt, ist
vollgestellt mit Tischen und Stühlen, die alle ebenfalls Objekte sind. Diese Tische
und Stühle kann man nun im Raum bewegen. Auÿerdem hat jeder Tisch und Stuhl
eigene Eigenschaften. So kann ein Stuhl zum Beispiel besetzt sein (Zustand), oder
man kann ihn auf einen Tisch stellen (eine Aktion, an der dann ein Tisch- und ein
Stuhlobjekt beteiligt sind). Auch kann man einen Stuhl aus diesem Raum entfernen
und in einem anderen Zusammenhang benutzen, das bedeutet, dass gleiche Klassen
in verschiedenen Programmen genutzt werden können (man sagt auch, Java ist
modular ). Diese Modularität macht auÿerdem eine verteilte Programmierung
möglich, so dass an einem Programm viele Programmierer arbeiten und einfach Quellcode
ergänzen oder austauschen können. Für die objektorientierte Programmierung
sind die Konzepte von Klassen und Objekten von grundlegender Bedeutung.
2.1.1. Klassen
Betrachten wir zuerst den Begri Klasse. Eine Klasse beschreibt das allgemeine
Konzept, also welche Eigenschaften ein Objekt hat, was es kann und wie es sich verhält.
Von einer Klasse können viele Objekte erzeugt werden. Im Wombat-Szenario
von Greenfoot gibt es die Klasse Wombat. Diese beschreibt sozusagen alle Wombats.
Sobald wir eine Klasse in Greenfoot angelegt haben, können wir davon Objekte erzeugen.
Objekte werden in der Programmierung oft auch als Instanzen bezeichnet.
2.1.2. Objekte
Eine Klasse ist nur eine Beschreibung (Kuchenrezept). Ein Objekt ist ein konkretes
Ding (also ein nach dem Rezept gebackener Kuchen). Die Klasse an sich kann erst
einmal wenig. Alle Eigenschaften und Fähigkeiten, die die Klasse beschreibt, werden
erst beim erzeugen eines Objektes der Klasse, also beim Instanziieren, verfügbar. Die
Klasse ist das Rezept, das man nicht essen kann. Es steht in diesem Rezept jedoch,
wie ein Kuchen gebacken wird und woraus er besteht. Erst das konkrete Objekt, also
der Kuchen, kann dann geschnitten und gegessen werden.
8

Denition
Generell gilt die Denition:
Ein Objekt ist eine Instanz einer Klasse
2.2. Ein Szenario önen und starten
Information
Greenfoot organisiert zusammengehörende Klassen in sogenannten Szenarien.
Wenn ihr Greenfoot das erste mal startet, müst ihr im sagen, welches
Szenario ihr haben wollt. Dafür geht ihr im Menü auf: Szenario -> Open
und wählt das Szenario Wombats.
Dieses Szenario wollen wir nun als erste Grundlage nehmen. Damit ihr
es euch nicht überschreibt, speichert es bitte unter einem neuen
Namen. Geht dafür wie folgt vor:
• Önet den Speichern Dialog: Szenario -> Save a Copy as
• Wählt euer Netzlaufwerk (w:) und erzeugt euch einen neuen Ordner
• Speichert das Szenario in diesem ordner
Alternativ kannst du es auch auf deinem USB-Stick speichern oder ein
Szenario in's LoNET stellen.
Jetzt bist du fast bereit für die ersten Schritte, aber vorher noch ein
paar Informationen, die dir im weiteren Verlauf das Lesen und Verstehen
der Programme erleichtern.
9

Information
2.3. Was können Klassen
Eine jede Klasse beschreibt, welche Fähigkeiten (Methoden) und Eigenschaften
(Variablen / Konstnaten) ein aus ihr erstelltes Objekt hat.
2.3.1. Methoden
Methoden beschreiben, welche Fähigkeiten eine Klasse hat. Hier steht der
eigentliche Programmcode, also was ein Objekt der Klasse machen soll.
Öne einmal das Scenario Wombats. Vergiss nicht, es unter einem neuen
Namen in deinem Verzeichnis zu speichern.
Wenn du mit der rechten Maustaste auf die Klasse Wombat klickst
(rechts im Klassendiagramm), springt ein Kontextmenü zu dieser Klasse
auf. Die erste Option in diesem Menü, new Wombat() erzeugt ein neues
Wombat-Objekt. Probiere es einfach aus. new Wombat() ist übrigens
eine spezielle Methode, der sogenannte Konstruktor.
Jetzt wird das Bild eines kleinen Wombat Objekts eingeblendet, das
du mit deiner Maus auf dem Bildschirm verschieben kannst. Platziere
den Wombat irgendwo in der Welt, indem du an eine beliebige Position
klickst. Klickst du nun mit der rechten Maustaste auf den Wombat, so
önet sich ein neues Popup - Menü, in dem alle benutzbaren Methoden
aufgeführt werden. Schau dir diese Methoden einmal genau an, teste sie
aus und nde heraus, was passiert.
10

Denition
Jeder Methodenkopf (auch Signatur genannt), also das, was ihr
im Menü seht, ist übrigens wie folgt aufgebaut:
Sichtbarkeit Rückgabetyp Methodenname (Parameter)
Die einzelnen Bestandteile sind im Folgenden kurz beschrieben.
Sichtbarkeit Methoden sind der Mechanismus, mit dem einzelne Objekte
miteinander interagieren können. In unserem Szenario kann zum Beispiel
der Benutzer (über die Welt) einzelne Methoden des Wombats aufrufen
und diesen somit steuern. Alle Methoden, die von Auÿen aufrufbar sind,
haben die Sichtbarkeit public.
Manchmal möchte man jedoch Methoden nicht für alle verfügbar machen.
Stell dir vor, in einem Spiel hat eine Klasse eine Methode, um das Passwort
eines Spielers zu prüfen. Würde man diese von auÿen aufrufen können,
so könnte man so oft versuchen, das Passwort zu raten, bis man es gefunden
hat, ohne dass das Programm es merkt. Für diesen Fall gibt es
die Möglichkeit, solche Methoden als private zu kennzeichnen. Private
Methoden können nur vom Objekt selber aufgerufen werden.
Mit Hilfe der Sichtbarkeit kann man Methoden verstecken
oder nach Auÿen hin verfügbar machen.
Rückgabetyp Der Rückgabetyp einer Methode gibt an, welche Art von
Antwort (Datentyp) nach Beenden der Methode zurückgegeben wird. Dies
kann zum Beispiel eine der folgenden sein:
• int Es wird eine ganze Zahl zurück gegeben
Es wird entweder true (wahr) oder false (falsch) zurück-
• boolean
gegeben
• void Es wird gar nichts zurückgegeben
11

Über den Rückgabewert kann man zum Beispiel Ergebnisse einer Rechnung
erhalten oder sich Eigenschaften des Objektes anzeigen lassen (so
genannte GetterMethoden, da die Methodennamen mit get anfangen).
Parameter Mit Hilfe von Parametern kann man Methoden beim Aufruf
gewisse Informationen mitgeben. Diese werden dann von der Methode
während der Verarbeitung genutzt. Ein einfaches Beispiel wäre die Methode
public int addiere(int zahl1, int zahl2), welche zwei ganze Zahlen
übergeben bekommt und (wahrscheinlich) deren Summe zurückgibt. Parameter
gelten innerhalb der aufgerufenen Methode als Variablen.
2.3.2. Aufgabe zum Thema Methoden
Wissenssicherung
Aufgabe1 Es gibt spezielle Methoden, sogenannte Setter-Methoden, die
dafür genutzt werden, um Variablen eines Objektes zu verändern. setDirection()ist
so eine Methode. Finde heraus, welchen Sinn sie hat und
beschreibe ihr Verhalten. Vielleicht fällt dir dabei etwas seltsames auf.
Aufgabe2 Finde drei weitere unterschiedliche Methoden des Wombat und
deute ihre Methodenköpfe. Gib also an, welche Sichtbarkeit gilt und welche
Parameter es gibt und was zurückgegeben wird.
12

2.3.3. Variablen und Konstanten
Informaiton
Methoden beschreiben Fähigkeiten von Objekten, Variablen beschreiben
Eigenschaften. Ein Tisch hat zum Beispiel die Variable anzahlBeine, in
der festgehalten wird, wie viele Beine er hat.
Jede Variable hat einen Namen und einen Datentyp. Zunächst
wird eine Variable deniert (man sagt auch deklariert indem man
genau diese beiden Faktoren festlegt.
int anzahlBeine;
deklariert eine Variable anzahlBeine vom Datentyp int (ganze Zahl).
Jede deklarierte Variable muss auch initialisiert werden, bevor sie
genutzt werden kann. Dies tut man zum Beispiel durch eine Zuweisung.
anzahlBeine=4;
weist der Variable ihren ersten Wert zu.
Beides kann man auch in einer Zeile machen:
int anzahlBeine=4;
Das Semikolon am Ende einer Zeile bedeutet übrigens, dass hier eine
Anweisung zu ende ist. Es wird in Java zwingend benötigt.
Primitive Datentypen Für den Anfang reichen uns folgende einfache (oder
primitive) Datentypen:
• int - Ganze zahlen
• char - einzelne Zeichen (Character)
• boolean - wahr oder falsch
13

• oat - Flieÿkommazahlen (z.B.: 3.421)
Variablen kann man überall im Programm deklarieren, dabei macht es
jedoch einen Unterschied, wo man dies tut. Deklariere ich eine Variable
auÿerhalb einer Methode, gilt sie für das gesamte Objekt (Objektoder
Instanzvariable; globale Variable). Deklariere ich eine Variable
innerhalb einer Methode, gilt diese nur innerhalb dieser Methode
(lokale Variable).
Hilfe, nicht so schnell! All diesen Kram sieht man übrigens erst dann, wenn
man einen Wombat önet (durch Doppelklicken im Klassendiagramm).
Es önet sich ein Editor mit dem Quelltext, den du jetzt noch nicht
verstehen musst. Wenn du magst kannst du aber gerne schon einmal eine
Deklaration oder Initialisierung einer Variablen suchen.
2.4. Lernkontrolle
Lernkontrolle
Überprüfe an der folgenden Liste, ob du mittlerweile weiÿt, was diese
Begrie bedeuten und wie sie zusammenhängen.
Ich kenne jetzt:
• Klassen - Beschreiben Eigenschaften und Werte von Objekten (Rezept)
• Objekte - Sind konkrete Instanzen einer Klasse (Kuchen)
• Variablen - Sind Merker für Werte.
• Methode - Objekte haben Methoden, das Aufrufen von Methoden
führt Aktionen aus. Objekte können eigene Methoden oder Methoden
von von ihnen bekannten Objekten ausführen.
• Parameter - Werte, die man beim Aufruf einer Methode übergibt,
nennt man Parameter. Diese gelten für genau diesen Aufruf der
Methode.
14

• Rückgabetyp - Methoden können Werte zurückliefern, die einen Datentyp
haben.
• Sichtbarkeit - Veröentlichen oder verstecken von Methoden.
• primitive Datentypen - Einfache Datentypen, die nur Werte speichern,
aber nichts mit ihnen machen können.
Wenn du dir sicher genug bist, mache den Kapiteltest.
2.5. Kapiteltest
Kapiteltest
Der Kapiteltest für das erste Kapitel wird zu Beginn der nächsten
Stunde durchgeführt. Er gilt als schriftliche Hausaufgabenüberprüfung.
15

3. Kapitel II - Das erste Szenario
Übersicht
In diesem Kapitel wirst du lernen, den Wombat von Hand zu steuern
und seine Methoden zu nutzen. Auÿerdem wirst du eine Möglichkeit kennenlernen,
um den Wombat zu automatisieren.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Aufrufen der einzelnen Methoden des Wombat
• Übergabe von Parametern
• Interaktion mit anderen Objekten
• Die Methode act()
16

3.1. Steuern des Wombat per Hand
Aufgabe
Zunächst einmal sollst du erkunden, was die einzelnen Methoden des
Wombat bewirken. Starte dazu Greenfoot und öne das Tutorial oder
das Szenario wombats.
Hier ndest du im Klassenbaum die Klassen Wombat und Leaf.
Erzeuge ein neues Objekt der Klasse Wombat (rechter Mausklick auf die
Klasse, dann Auswahl des Konstruktors) und platziere ihn mittig auf der
Welt. Erzeuge dann ein neues Objekt der Klasse Leaf und platziere es
ein paar Felder rechts vom Wombat. Deine Welt sollte jetzt ungefähr so
aussehen:
17

Abbildung 2: Ein Wombat auf der Welt
Wenn du nun mit rechts auf den Wombat klickst, kannst du wie gewohnt
die Methoden des Wombat auswählen. Einige hast du mit Sicherheit schon
ausprobiert.
Jetzt ist deine Aufgabe, den Wombat mittels der Methoden auf das
Blatt zu setzen und dann das Blatt zu essen. Dabei schreibst du bitte
bei jedem Schritt auf (entweder als Text, oder, wenn du es schon/noch
kannst, als FlowChart 3 ), welche Methode du wann genutzt hast.
Wiederhole dein Verfahren und platziere dabei das Blatt an anderen
Stellen in der Welt. Finde dabei auch heraus, was die Methode foundLeaf()
macht und überlege, warum du sie nicht benötigst, der Wombat anscheinend
aber schon.
3 Siehe Exkursion 1
18

3.2. Automatisches Steuern des Wombat - Die Methode act()
Information
Jede Klasse, die es in Greenfoot gibt, hat eine Methode act(). In
dieser wird beschrieben, wie sich ein entsprechendes Objekt verhalten soll,
wenn die Welt schrittweise oder fortlaufend automatische Züge macht (hierzu
dient die Steuerung am unteren Bildschirmrand). Stelle einmal einen
Wombat auf die Welt und lasse ihn mit Hilfe der Steuerung schrittweise
laufen. Stelle dann mehrere Wombats auf die Welt, was geschieht nun?
Aufgabe
Erstelle noch einmal einen Wombat und ein Blatt und positioniere sie
wie oben beschrieben. Führe dann zunächst einzelne Züge der Welt automatisch
durch, indem du das entsprechende Icon (Act) in der Kontrolleiste
anwählst. Beschreibe dabei das Verhalten des Wombat. Positioniere
weitere Blätter in der Welt und teste, was geschieht.
19

3.2.1. Der erste Quellcode-Fetzen
OK, unser Wombat tut bereits Dinge automatisch, aber wie? Naja, im
Grunde macht er nichts anderes, als seine eigenen Methoden zu bentuzen.
Wie er sie anzuwenden hat, steht im Quellcode in der Methode act().
Diese sieht wie folgt aus:
1 public void act ()
2 {
3 if ( foundLeaf ()) {
4 eatLeaf ();
5 }
6 else if ( canMove ()) {
7 move ();
8 }
9 else {
10 turnLeft ();
11 }
12 }
Listing 1: Die Act-Methode des Wombat
Das sieht jetzt schlimmer aus, als es ist. Wenn du schon etwas programmieren
kannst, sollte dir das Verständnis der Methode keine Schwierigkeiten
machen, wenn nicht, dann lernst du nun, wie man Quellcode liest, wenn
man die Sprache noch nicht gut kann:
• Aufgabe 1: Übersetze den Quellcode zunächst Wort für Wort
ins Deutsche. Versuche dann das Verhalten in ganzen Sätzen zu
beschreiben.
• Aufgabe 2: Vergleiche das Verhalten mit dem übersetzten Text ab,
bestimmt ndest du Zusammenhänge.
• Aufgabe 3: Überlege, warum der Wombat mit diesem Programm
nicht alle Blätter in der Welt nden kann.
Einige der Befehle sind gut verständlich, andere machen dir vielleicht
noch Probleme, das ist aber nicht schlimm, denn die act-Methode werden
wir uns im nächsten Kapitel noch genauer anschauen.
20

3.3. Lernkontrolle
Lernkontrolle
Überprüfe an der folgenden Liste, ob du mittlerweile weiÿt, was diese
Begrie bedeuten und wie sie zusammenhängen.
Ich kenne jetzt:
• die einzelnen Methoden des Wombat und kann sie benutzen, um den
Wombat zu steuern
• die Methode act() und kann das Verhalten des Wombat deuten
Wenn du dir sicher genug bist, mache den Kapiteltest.
3.4. Kapiteltest
Kapiteltest
Der Kapiteltest für dieses Kapitel wird in Einzelarbeit absolviert.
21

4. Exkursion I - FlowCharts
Übersicht
In diesem Extrakapitel kannst du dir schnell einen Überblick darüber
verschaen, oder wiederholen, was FlowCharts sind. Wenn du dir sicher
bist, dass du noch weiÿt, wie Flowcharts funktionieren, kannst du diese
Exkursion überspringen.
Lernziele
In diesem Kapitel wirst du die folgenden Elemente eines FlowCharts
kennenlernen:
• Start/Stop
• Ein-/Ausgabe
• Operationen
• Überprüfungen / Entscheidungen
• Unterprogramme (Blöcke)
• Ablaufpfeile
• Schleifen
22

4.1. Grundlegende Elemente
Information
FlowCharts, auch Ablauf- oder Fluÿdiagramme genannt, werden dazu
genutzt, um die einzelnen Schritte eines Algorithmus 4 oder Programms
zu visualisieren (also grasch zu verdeutlichen). An Hand der Diagramme
kann man dann Stück für Stück überprüfen, was ein Programm
wann macht. FlowCharts sind vor allem für kleinere Programmabläufe
und Algorithmen, nicht aber für groÿe Programme oder Projekte geeignet.
Zuerst wirst du die einzelnen Symbole kennenlernen und dann ihre Anwendung
an Hand von zwei Beispielen nachvollziehen können.
4.1.1. Start / Stop
Jeder Algorithmus hat einen denierten Anfangspunkt und zumindest ein
Ende. Diese beiden Punkte werden durch Ovale symbolisiert, in die die
Worte Start und Stop eingeschrieben sind.
Abbildung 3: Start und Stop
4.1.2. Eingabe und Ausgabe
Um das Eingeben und Ausgeben von Werten zu verdeutlichen, nutzt man
in FlowCharts das Parallelogramm. Dabei gibt man bei der Ausgabe
entweder eine Variable an, die ausgegeben werden soll, oder einen Flieÿtext
(in Anführungszeichen). Bei der Eingabe weist man einer Variable
4 Diesen Begri werden wir später genauer behandeln
23

Abbildung 4: Ein- und Ausgabe
(evtl. unter Festlegung des Datentyps) einen Wert zu.
Hier wird zunächst die Variable Zahl1 als Ziel der Eingabe angegeben.
Ihr Datentyp ist int (Ganzzahl). Bei der Ausgabe wird dann der Wert
wieder ausgegeben. Um zu verdeutlichen, dass es sich um eine Ausgabe
handelt, wird hier ein Pfeil nach rechts vorangestellt. Man kann auch
mehrere Ein-, bzw. Ausgaben in einem Schritt zusammenfassen.
4.1.3. Operationen
Immer, wenn etwas berechnet onder verändert wird, benutzt man im
FlowChart das Operation Symbol, ein Rechteck, in dem beschrieben
wird, was verändert wird.
Abbildung 5: Operationen
Hier wird in beiden Fällen der Wert der Variable Zahl1 um eins erhöht
(man spricht vom sogenannten Inkrement, die zweite Schreibweise ist
eine Kurzschreibweise). Zahl1 muss natürlich vorher deniert und initialisiert
werden.
4.1.4. Entscheidungen
In den meisten Algorithmen oder Programmen muss irgendwann eine
Auswahl für das weitere Vorgehen getroen werden. Hierfür gibt es das
Entscheidungs-Symbol, eine auf der Ecke stehende Raute. Im Symbol
24

ist die Bedingung eingeschrieben, die überprüft werden soll. Vom Symbol
weg führen zwei Pfeile, einer für den Fall, dass die Bedingung zutrit,
einer für den Fall, dass sie nicht zutrit.
Abbildung 6: Bedingte Verzweigung
4.1.5. Unterprogramme / Blöcke
Manchmal ist ein Programm oder Algorithmus zu groÿ, um ihn übersichtlich
in einem einzelnen Diagramm darstellen zu können, oder es werden
an mehreren Stellen die gleichen Sequenzen von Operationen, Programmblöcke
(oder Funktionen) genannt, benötigt. Hier kann man folgendes
Symbol verwenden, um darzustellen, dass ein Unterprogramm gestartet
wird.
Abbildung 7: Subprogramm
4.1.6. Ablaufpfeile und Schleifen
Die einzelnen Symbole im FlowChart werden durch Pfeile verbunden,
die angeben, welcher Programmschritt folgt. Dabei können Pfeile nicht
nur von oben nach unten zeigen, sondern auch von einem Programmteil
zu einem früheren Programmteil zurück führen. Dies nennt man eine
25

Schleife 5 , so können einzelne Teile eines Algorithmus wiederholt werden.
Abbildung 8: Addition über Inkrement und
Dekrement
Hier einmal zwei kleine Beispiele
für FlowCharts. Das erste Beispiel
ist die Addition von zwei Zahlen
über das Bilden von Inkrement
und Dekrement, also das
erhöhen, bzw. erniedrigen des
Wertes einer Variable vom Typ
int um 1.
Im Algorithmus wird Zahl1 so
lange um eins verringert, bis
ihr Wert null ist. Auÿerdem
wird der Wert von Zahl2 in jedem
Durchlauf um eins erhöht,
das Ergebnis der Addition steht
nachher in Zahl2.
Es folgt ein weiteres Beispiel,
welches die Werte von zwei
Variablen vergleicht und die gröÿere der beiden Zahlen ausgibt.
5 Schleifen gibt es auch in Java, mehr dazu später
26

Abbildung 9: Ein Algorithmus zum Vergleichen von zwei Zahlen
27

4.2. Belegungstabellen
Um in einem Programm nicht den Überblick über die Werte der einzelnen
Variablen zu verlieren, kann man Belegungstabellen aufstellen. Dabei gibt
es eine Spalte für jede Variable und jeder Schritt leitet eine neue
Zeile ein. Weitere Spalten für Programmschritt und Ausgabe machen
die Tabelle aussagekräftiger. Wollen wir zum Beispiel die Zahlen 3 und
5 mit Hilfe des oberen Algorithmus addieren, kann eine Belegungstabelle
wie folgt aussehen:
Abbildung 10: Eine Beispielbelegungstabelle
4.3. Lernkontrolle
Lernkontrolle
Du solltest nun einfache FlowCharts lesen und den dargestellten Algorithmus
verfolgen können. Um die Benutzung einzuüben gibt es hier noch
eine Anwendungsaufgabe zum Lesen von FlowCharts.
Schau dir das folgende FlowChart an und versuche herauszunden,
28

Aufgabe
welche mathematische Funktion hier dargestellt wird. Benutze dazu auch
eine Belegungstabelle.
Abbildung 11: Was tut dieser Algorithmus?
4.4. Eigene FlowCharts erstellen
Um schnell eigene FlowCharts zu erstellen, gibt es eine Reihe von Programmen
im Internet. Eines, welches noch mehr als FlowCharts kann und
zusätzlich kostenlos ist, ist das Programm DIA 6 , welches im Internet
heruntergeladen werden kann. Hiermit lassen sich mit ein wenig Übung
schnell eigene FlowCharts erstellen.
Dia gibt es auch auf den PC in der Schule. Du darfst es gerne zu Erzeugung
von FlowCharts und anderen Diagrammen benutzen.
6 Download unter http://dia.sourceforge.net
29

5. Kapitel III - Erste Schritte im Quelltext
Übersicht
In diesem Kapitel wirst du die einzelnen Methoden des Wombat genauer
betrachten und lernen, die einzelnen Aktionen zu kombinieren.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Die Methode act() zur automatischen Durchführung von Schritten.
• Die Kontrollstruktur if-Anweisung zum Durchführen von Entscheidungen.
• Das Strukturieren und Kommentieren von Quelltext.
• Flags als Zustandsmerker
30

5.1. Die Methode act()
Information
Schaue dir mit Hilfe eines Doppelklicks den Quellcode des Wombat an
und suche die Methode act(). Die Methode wird immer dann ausgeführt,
wenn die Welt einen Programmschritt macht und sollte ungefähr
wie folgt aussehen:
Listing 2: Die Methode act()
1 /**
2 * Tut, was ein Wombat so tut ...
3 */
4 public void act ()
5 {
6 if ( foundLeaf ()) {
7 eatLeaf ();
8 }
9 else if ( canMove ()){
10 move ();
11 }
12 else {
13 turnLeft ();
14 }
15 }
Dir sollten einige Dinge im Quellcode schon bekannt vorkommen. Da
Java englische Begrie benutzt, sollten dir aber auch der Rest nicht all
zu viele Probleme machen.
31

5.1.1. Kommentare
Schau dir zunächst die ersten paar Zeilen (die mit den *) an. Die hier stehenden
Sätze stellen Kommentare dar, sie sind nicht für den Computer
gedacht, sondern für den Programmierer. Da Java als objektorientierte
Programmiersprache hoch modular aufgebaut ist (es gibt viele Klassen,
die man kombinieren kann und die von unterschiedlichen Programmierern
geschrieben werden), verliert man leicht den Überblick. Daher ist es
wichtig, den Quellcode mit Kommentaren zu versehen. Aufschreiben sollte
man dabei, was eine einzelne Methode macht und welche Funktion die
übergebenen Parameter haben. Je mehr man in den Kommentar schreibt,
desto einfacher ist es, später noch zu wissen, was ein Stück Programmcode
tut. Im allgemeinen ist es egal, in welcher Sprache man Kommentare
schreibt, um Klassen aber bestmöglich teilen zu können, solltet ihr später
Kommentare in Englisch schreiben.
Es gibt drei Arten von Kommentaren, von denen eine eine besondere
Funktion hat.
• Einzeilige Kommentare - Diese beginnen mit //. Alles in der
Zeile hinter den Schrägstrichen wird vom Computer nicht gelesen.
• Mehrzeilige Kommentare - Diese beginnen mit /*. Jede weitere
Zeile Kommentar bekommt am Anfang wieder ein *, beendet wird
der Kommentarblock mit */.
• Javadoc Kommentare - Diese Kommentare sind ebenfalls mehrzeilig
und beginnen jedoch mit /**. Sie haben den Vorteil, dass man
sie automatisch in eine Anleitung (HTML-Datei) umwandeln kann.
Javadoc Kommentare stehen vor Klassen- oder Methodensignaturen
und können Schlüsselwörter (z.B. @param, @author, @return) enthalten.
32

Hier einmal ein Beispiel:
Listing 3: Addieren von zwei Zahlen
1 /**Diese Methode addiert zwei Zahlen.
2 *@author Kretschmer
3 *@param zahl1 Erster Summand.
4 *@param zahl2 Zweiter Summand.
5 *@return Summe der beiden Zahlen.
6 */
7 public int addiere ( int zahl1 , int zahl2 )
8 {
9 /*Addition in drei Schritten:
10 * Definition einer Zwischenvariable
11 * Zuweisung des Wertes der Berechnung
12 * Rückgabe der Ergebnisses
13 */
14 int ergebnis ; //Deklaration ergebnis,Typ int
15 ergebnis = zahl1 + zahl2 ; //Berechnung und Zuweisung
16 return ergebnis ; //Rückgabewert
17 }
Die erzeugte JavaDoc Datei läÿt sich dann in einem Browser darstellen.
Durch JavaDoc kann
man schnell und einheitlich
einen Überblick über die
verwendeten Klassen und
ihre Methoden erstellen.
Wichtig für uns ist hier
die Java API 7 , die
einen Überblick über alle
Klassem und Methoden
liefert, die Java selber
mitbringt.
Abbildung 12: JavaDoc erzeugt schöne Methodenbeschreibungen
7 Du ndest sie auf der Seite von Sun, sun.java.com
33

Auch Greenfoot erzeugt JavaDoc Kommentare. Du kannst die Dokumentation
zu einer Klasse önen, indem du zunächst ihren Quelltext
önest und dann rechts oben an Stelle von Quelltext den Eintrag für
Kommentare auswählst.
Ein guter Vorsatz ist es, für jede Zeile Quellcode eine Zeile Kommentar
zu schreiben.
5.1.2. Einrückung
Dir wird aufgefallen sein, dass die einzelnen Zeilen im Quelltext nicht immer
am Anfang einer Zeile beginnen, sondern eingerückt sind. So wird
schnell klar, welche Befehle zu einem gemeinsamen Codeblock gehören.
Der Text wird übersichtlich und von Menschen gut verständlich.
Generell gilt, dass man für jeden neu beginnenden Block um eine feste
Breite (z.B. zwei Zeichen) einrückt und am Ende des Blockes wieder zwei
Zeichen zurück geht. Viele Editoren machen dies automatisch, Greenfoot
gehört glücklicherweise dazu.
5.1.3. Was macht der Code - Schrittweises Durchgehen
Las uns nun zusammen den Quellcode der Methode act() Stück für
Stück durchgehen. Die ersten paar Zeilen sind, wie bereits erwähnt JavaDoc
Kommentare.
Es folgt die Methodensignatur. Du solltest bereits mit einem Satz
beschreiben können, was eine Signatur über die Methode aussagt. Hier
könnte man zum Beispiel folgendes sagen:
Die Methode act() ist für alle Objekte, die dieses Objekt kennen, sichtbar
und besitzt weder Parameter noch einen Rückgabewert.
Dann folgt der Methodenkörper, also der eigentliche Quellcode, eingeschlossen
in geschweifte Klammern. Beachte, dass der folgende Code eingerückt ist.
In der ersten Zeile Methodencodes ndest du nun etwas Neues. Die Kontrollstruktur
If-Anweisung , die man dazu benutzen kann, Entscheidungen
zu treen.
34

5.1.4. Die If-Anweisung
Aus den FlowCharts kennst du dieses Konstrukt bereits als Überprüfung.
Schauen wir uns die Zeilen einmal genauer an und übersetzen den Code
in's deutsche:
Listing 4: Eine kleine Verhaltensregel ...
1 if ( foundLeaf ()) eatLeaf (); // Wenn Blatt gefunden iss es
2 else { // Sonst beginne neuen Block
3 if ( canMove ()) // Wenn du dich bewegen kannst,
4 move (); // bewege dich
5 else turnLeft (); // Sonst drehe dich links
6 } // Ende des "Sonst" Blocks
Was geschieht, sollte nun also klar sein.
Eine If-Anweisung ist immer wie folgt aufgebaut:
if (BEDINGUNG1 [&& BEDINGUNG2]) AKTION1 [else AK-
TION2]
Eine Bedingung ist entweder eine direkte Überprüfung (z.B. x>3, y==5,
z!=6, also z ungleich 6) oder ein Aufruf einer Methode, die den Rückgabetyp
boolean hat.
Der Else-Teil muss nicht immer vorhanden sein, kann aber eine neue If-
Abfrage einleiten (else if...). Auÿerdem kann man mit einer Abfrage auch
direkt zwei Bedingungen überprüfen, indem man sie mit && (UND),
bzw || (ODER) verbindet.
35

5.1.5. Code und FlowChart
Aufgabe
Überführe den Quellcode der Methode act() nun in ein FlowChart, dafür
darfst du immer dann, wenn eine andere Methode aufgerufen wird, das
Symbol Programmblock benutzen.
5.1.6. Den Wombat automatisch positionieren
Für die weiteren Stunden müssen wir den Wombat zunächst dazu bringen,
sich von einer beliebeigen Position aus in die linke obere Ecke zu stellen.
Aufgabe
Überlege zunächst mit deinem Partner, wie man den Wombat dazu
bringt, sich in die linke obere Ecke zu bewegen, ohne zwischendurch Blätter
zu essen. Nachdem der Wombat die Ecke erreicht hat soll er sich so
drehen, dass er nach rechts schaut. Wenn ihr eine brauchbare Idee habt,
versucht die Methode act() so zu verändern, dass der Wombat euren
Regeln folgt.
36

5.1.7. Man fängt am Ende an - Eine kleine Hilfe
Bevor man wie wild mit dem Programmieren beginnt, ist es sinvoll, zu
klären, wie genau das Ergebnis aussehen soll, das ich mit Hilfe des Programms
erreichen möchte. Als nächstes betrachtet man das System in
dem man sich bewegt und welche Regelmäÿigkeiten und Einschränkungen
es gibt. Dann macht man sich Gedanken über die möglichen Ausgangssituationen
und versucht als letztes, die einzelnen Schritte zum Ziel
zu formulieren.
Für unser Beispiel bedeutet das folgendes:
• Der Wombat soll am Ende in der linken oberen Ecke stehen und nach
rechts schauen (Richtung Ost).
• Die Welt ist begrenzt durch Ränder, über die der Wombat nicht
hinauslaufen kann. Auÿerdem kann der Wombat sich im Moment
nur links herum drehen.
• Der Wombat kann irgendwo in der Welt beginnen, seine Richtung ist
nicht vorgegeben, läÿt sich aber über die Methode getDirection()
herausbekommen.
• Tip: Um zum Ziel zu kommen, muss man zunächst entweder die
obere oder die linke Wand nden. Dann die entsprechend andere
Wand, als letztes muss man sich drehen. Vielleicht ist es auch von
Interesse, eine Methode dreheRechts() zu schreiben.
Jetzt hat man schon einmal einen grundlegenden Plan und könnte diesen
zum Beispiel mittels FlowChart genauer formulieren.
Wenn du dieses versuchst wirst du dir die folgende Frage stellen müssen:
37

5.2. Flags - Merker
Wenn die act() Methode in jedem Durchgang von neuem beginnt, wie
kann ich mir merken, ob ich schon eine Wand gefunden habe?
Für diesen Fall gibt es zum Glück Merkvariablen, so genannte Flags,
die nur dafür da sind, sicherzustellen, dass Informationen nicht verloren
gehen. Diese Variablen müssen auch über einen Durchlauf der act() Methode
hinaus gültig bleiben, es müssen also Klassenvariablen sein.
Am besten, du erzeugst zwei Variablen vom Typ boolean (diese können
die Werte true und false annehmen und lassen sich daher direkt
mittels If-Anweisung überprüfen). Dann musst du diese am Anfang nur
entsprechend setzen (z.B. auf false, am besten im Konstruktor) und umschalten,
wenn du eine entsprechende Wand gefunden hast.
Mit all diesen Informationen solltet ihr es schaen, die Aufgabe zu erfüllen!
38

5.3. Lernkontrolle
Lernkontrolle
Überprüfe an der folgenden Liste, ob du mittlerweile weiÿt, was diese
Begrie bedeuten und wie sie zusammenhängen.
Ich kenne jetzt:
• Kommentare - Du kennst die verschiedenen Koommentartypen und
weiÿt, was JavaDoc Kommentare sind.
• If-Anweisung - Du kennst die If-Anweisung und weiÿt, was eine Überprüfung
ist.
• Die act()-Methode - Du kennst die Methode und weiÿt, wozu sie
dient.
• Flags
Wenn du dir sicher genug bis, mache den Kapiteltest.
5.4. Kapiteltest
Kapiteltest
39

6. Kapitel IV - Hungrige Wombats
Übersicht
In diesem Kapitel wirst du den Wombat so programmieren, dass er alle
Felder abgeht und dabei alle Blätter ist. Dabei musst du überlegen, wie
er sich bewegen soll.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Der Begri Algorithmus wird eingeführt
• Vom Algorithmus zum Programm
40

6.1. Erweiterung unseres Programms
Aufgabe
Versuche nun, die folgende Aufgabe zu lösen:
Finde einen Weg zum Durchlaufen aller Felder der Welt
Hierbei kommt es nicht auf die Reihenfolge an, in der die Felder abgearbeitet
werden, sei also kreativ.
Formuliere dafür zunächst einen Algorithmus, veranschauliche diesen
dann als FlowChart und führe am Schluss eine Implementierung (also
das eigentliche Schreiben der Methode) durch.
6.2. Was ist ein Algorithmus überhaupt?
6.2.1. Denition - Algorithmus
Denition
Ein Algorithmus ist eine formale Beschreibung für ein Vorgehen oder
eine Lösungsvorschrift, die sich auf einem automatischen System (z.B.
Computer) umsätzen läÿt. Diese Beschreibung muss dabei folgende Bedingungen
erfüllen:
• Ein A muss Terminieren, das heiÿt er ndet immer irgendwann ein
Ende. Dies ist nicht unbedingt bei jeder Lösungsvorschrift gegeben,
doch nur eine endliche Vorschrift läÿt sich zuverlässig auf einem Computer
umsetzen, da dieser sonst eventuell unendlich lange rechnet.
• Ein A ist eindeutig, er liefert also bei jedem Durchlauf für die selbe
Eingabe die selbe Ausgabe.
41

• Ein A ist sprachunabhängig und formal korrekt, denn nur so läÿt
er sich auf einem automatischen System umsetzen
Eine Darstellungsweise für Algorithmen kennst du schon. FlowCharts
ermöglichen genau die geforderte, formale Darstellung.
6.2.2. Beispiele zur Darstellung
Wissenssicherung
Im Exkursionstest zum Thema
FlowCharts hast du bereits
einige einfache Algorithmen
kennengelernt. Hier gibt
es einen weiteren Algorithmus,
zunächst in Pseudocode,
einem Zwischending zwischen
normaler Sprache und Programmcode,
und dann als FlowChart.
1 01 BEGIN
2 02 INPUT a
3 03 INPUT b
4 04 c =0
5 05 IF (a >b) GOTO 09
6 06 b=b -a
7 07 c=c +1
8 08 GOTO 05
9 09 OUTPUT c
10 10 END
Abbildung 13: Ein weiterer unbekannter
42

Aufgabe
Beschreibe mit eigenen Worten, was der Algorithmus tut. Stelle dabei
auch heraus, warum die ersten beiden Forderungen für einen Algorithmen
erfüllt sind.
Wissenssicherung
6.2.3. Umsetzen der eigenen Idee
Mit Hilfe der Anleitung aus dem letzten Kapitel und dem Wissen über
Flags solltet ihr eine Idee nden. Glücklicherweise ist der Startpunkt des
Wombat vorgegeben (links oben). Jetzt sollte es möglich sein, mit Hilfe
eines weiteren Merkers die Welt stückweise abzugehen. Solltet ihr Fragen
haben oder keine Idee, wie ihr anfangen sollt, spielt das Problem einmal
von Hand durch, indem ihr den Wombat durch aufrufen der entsprechenden
Methoden direkt bewegt.
6.2.4. FlowChart
Zeichnet dann ein FlowChart, entweder mit dem Programm Dia oder
von Hand. Lasst den Lehrer einmal drüberschauen und erklärt ihm euer
Vorgehen gegebenenfalls.
6.2.5. Implementation in der act() Methode
Setzt als letzten Schritt euren Algorithmus in Programmcode um und
beobachtet euer Ergebnis, indem ihr eine Welt mit einem Wombat und
einer Reihe von Blättern erzeugt. Findet der Wombat immer alle Blätter,
wenn ja, dann seit ihr fertig.
43

6.3. Lernkontrolle
Lernkontrolle
Überprüfe an der folgenden Liste, ob du mittlerweile weiÿt, was diese
Begrie bedeuten und wie sie zusammenhängen.
Ich kenne jetzt:
• Die genaue Denition des Algorithmusbegris
• Ein sinnvolles Vorgehen zum Lösen von Programmierproblemen
Wenn du dir sicher genug bist, mache den Kapiteltest.
6.4. Kapiteltest
Kapiteltest
Der Kapiteltest für dieses Kapitel wird in Einzelarbeit absolviert.
44

7. Kapitel V - Was uns Klassendiagramme alles sagen
Übersicht
In diesem Kapitel wirst du die UML-Klassendiagramme und die Java
API genauer kennen lernen. Beides sind Möglichkeiten, die Zusammenhänge
und Fähigkeiten verschiedener Klassen darzustellen. UML-Diagrammer
(UML = Unied Modelling Language) sind eine Reihe einheitlicher, weltweit
gültiger Darstellungsformen für die Modellierung von Systemen und Programmen
und UML-Klassendiagramme sind ein Teil davon. Die Java API
hingegen ist eher eine Art Lexikon, in dem man die Eigenschaften aller
Java-Klassen nachschlagen kann.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Das Grundgerüst einer Klasse (Klassensignatur)
• Wie werden Klassen und ihre Zusammenhänge mittels UML dargestellt
• Welche Informationen zu einer Klasse sind für andere Programmierer
wichtig
• Wie nde ich die Informationen zu den von Java gegebenen Klassen
in der API
45

7.1. Die Klassensignatur
Jede Klasse besteht, ähnlich einer Methode, aus der Signatur und ihrem
Körper. Dabei kann eine Klasse, genau wie eine Methode, verschiedene
Sichtbarkeiten haben.
Im Allgemeinen ist die Sichtbarkeit jedoch public. Wichtig ist, dass es
pro Datei nur eine Klasse mit der Sichtbarkeit public geben kann. Diese
muss dann auch genau so heiÿen, wie die Datei (ohne das .java).
Nach der Angabe der Sichtbarkeit wird mit dem Wort class angegeben,
dass es sich um eine Klasse handelt. Danach folgt der Klassenname (beginnt
vereinbarungsgemäÿ mit einem Groÿbuchstaben) und eventuelle eine
Vaterklasse 8 , sowie eine Liste von Interfaces (dazu später mehr).
Denition
Jede Klassensignatur sieht also wie folgt aus:
public class Klassenname [extends Vaterklasse] [implements Interface1[,I2...]{}
Die Klassensignatur der Klasse Wombat ist daher:
public class Wombat extends Actor{}
7.2. Klassendiagramme
Nachdem wir die Klassensignatur betrachtet haben, müssen wir nun überlegen,
was für jemanden, der mit einer Klasse arbeiten möchte, noch
wichtig sein könnte.
Wichtig sind zunächst einmal:
8 Vererbung wird im nächsten Kapitel behandelt
46

• Die Klassenvariablen (globale Variablen)
• Die Methoden einer Klasse (öentliche und evtl. auch private)
• Die Zusammenhänge mit anderen Klassen (für mögliche Interaktion)
All dies läÿt sich mit Hilfe der Klassendiagramme darstellen.
7.2.1. Eine einzelne Klasse beschreiben
Jede Klasse wird durch ein Rechteck symbolisiert, welches durch zwei horizontale
Linien in drei Teile aufgeteilt wird.
Im ersten Teil steht der Name der Klasse, im zweiten Teil eine Auistung
der Attribute (Variablen und Konstanten) und im dritten Teil eine
Liste aller Methoden. Hier mal ein Beispieldiagramm für die Klasse Wombat:
Abbildung 14: Klassendiagramm Wombat
Zeichenerklärung Beim Anschauen des Klassendiagramms sollte dir eine
gewisse Regelmäÿigkeit auallen. Die benutzten Zeichen und ihre Bedeutung
sind hier einmal aufgeführt.
• Jede Zeile in den beiden unteren Abschnitten beginnt mit einem
+ oder - zeichen, welche die Sichtbarkeit (+=public, -=private)
angeben.
47

• Nach dem Namen des Attributs folgt ein Doppelpunkt, dann der
Datentyp und (bei Konstanten) der Wert.
• Bei Methoden folgt nach dem Namen die Liste der Parameter in
Klammern und nach dem Punkt der Datentyp des Rückgabewerts
(oder Void).
• Geerbte Methoden und Attribute werden nicht aufgeführt (dazu unten
mehr).
• Der Konstruktor wurde als solcher gekennzeichnet.
Das Klassendiagramm wurde übrigens ebenfalls mit Dia erstellt.
48

7.2.2. Zusammenhänge
In einem Klassendiagramm lassen sich jedoch nicht nur einzelne Klassen
beschreiben, sondern auch die verschiedenen Zusammenhänge von Klassen
untereinander.
Nehmen wir einmal das gängige Beispiel eines Autos und schauen uns
dazu ein Klassendiagramm an:
Abbildung 15: Ein einfaches Klassendiagramm
Man sieht hier zwei Klassen, einmal die Klasse Auto mit einigen Eigenschaften
und Fähigkeiten. Auÿerdem die Klasse Fahrer. Jeder Fahrer hat
ein Auto, welches in UML durch einen Pfeil verdeutlicht werden. Jeder
Fahrer kennt sein Auto und kann auf dessen öentliche Variablen und
Methoden zugreifen.
7.3. Die Java API
Eine weitere Möglichkeit, Klassen zu beschreiben, bieten die JavaDoc-
Kommentare. In der sogenannten Java API sind alle Kommentare der
mit Java ausgelieferten Klassen aufgeführt. Man ndet die API auf der
Seite von Sun (Oracle) oder indem man nach den Begrien Java und
API im Internet sucht.
Eine wichtige Klasse, die wir uns nun genauer ansehen wollen, ist die
Klasse String .
49

7.4. Aufgabe
Aufgabe
Önet zunächst die Java API und sucht die Klasse String (links in der
Übersicht über alle Klassen).
Versucht nun, jeweils eine Methode zu nden, um:
• die Länge einer Zeichenkette zu bestimmen
• eine Zeichenkette in kleinbuchstaben umzuwandeln
• einen bestimmten Buchstaben in einer Zeichenkette zu nden
Zeichenketten lassen sich in Java mit dem Befehl System.out.println(zeichenkette);
ausgeben. Probiert nun einmal die gerade gefundenen Methoden aus.
Ab jetzt wird euch die API häuger begegnen und auch, wenn sie auf
Englisch ist, wird sie zu einem wichtigen Hilfsmittel beim täglichen Programmieren.
7.5. Lernkontrolle
Lernkontrolle
Überprüfe an der folgenden Liste, ob du mittlerweile weiÿt, was diese
Begrie bedeuten und wie sie zusammenhängen.
Ich kenne jetzt:
• Die UML Notation für Klassendiagrammen
• Die Java API, suchen und nden von Informationen
Wenn du dir sicher genug bist, mache den Kapiteltest.
50

7.6. Kapiteltest
Kapiteltest
Der Kapiteltest für dieses Kapitel wird in Einzelarbeit absolviert.
51

8. Kapitel VI - Vererbung und Interfaces
Übersicht
In diesem Kapitel wirst du erfahren, wie Vererbung in Java funktioniert
und wie man mit Hilfe von Interfaces weitere Vereinbarungen über die
Funktionen von Klassen festlegen kann.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Den Begri der Vererbung
• Welche Regeln es zu beachten gilt
• Wie man Methoden überlagert
• Wie man mit Hilfe von Interfaces vereinbarungen trit
52

8.1. Die Vererbungsidee
8.1.1. Information
Information
In vielen Programmiersprachen versucht man, Quellcode wieder zu verwenden
und nur durch kleine Änderungen zu erweitern. Auÿerdem macht
es oft Sinn, generelle Klassen durch Erweiterungen zu spezialisieren, so
dass aus ihnen generierte Objekte zum Einen neue Fähigkeiten und Eigenschaften
haben, zum Anderen aber immernoch Instanzen der Originalklassen
sind. Diesen Mechanismus nennt man Vererbung.
Ein kleines Beispiel aus dem alltäglichen Leben stellt die Führerscheinklasse
M, welche einem das Führen von Kleinkrafträder erlaubt. Desweiteren
gibt es die Klasse A1, welche das Führen von Krafträdern bis zu einer
Leistung von 25 kW gestattet. Das beinhaltet auch Kleinkrafträder der
Klasse M. Die Führerscheinklasse A1 (Kindklasse) erbt also sozusagen
von der Klasse M (Vaterklasse). Man sagt auch Die Klasse A1 erweitert
die Klasse M. Der Besitzer dieser Führerscheinklasse darf neue, stärkere
Maschinen fahren, aber er darf auch weiterhin mit seinem Mofa herumgurken.
Auÿerdem erweitert die Klasse A den Führerschein A1 noch einmal.
53

Ein weiteres Beispiel ist im Folgenden gegeben. Hier gibt es eine Klasse
Tier, die alle wichtigen Eigenschaften von Tieren enthält. Auÿerdem gibt
es die Klassen Maus und Elefant, welche Tier erweitern (diese also als
Vaterklasse haben). Im Quellcode sieht das Ganze dann so aus:
Listing 5: Die Klasse Tier
1 public class Tier extends Object {
2
3 public int alter ; // Jedes Tier hat ein Alter
4
5 public Tier () {
6 alter = 0; // Im allgemeinen beginnen Tiere bei 0
7 }
8
9 public void printAlter (){
10 System . out . println ( alter );
11 }
12
13 public void setAlter ( int alter ){
14 this . alter = alter
15 }
16
17 public void laufe (){
18 System . out . println (" laufe " );
19 }
20 }
Die Klasse Tier befähigt Tiere zum Laufen und gibt ihnen ein Alter,
sowie ein paar Methoden. Jetzt gibt es aber Tiere, die anders laufen, zum
Beispiel diese beiden:
Listing 6: Die Klasse Elefant
1 public class Elefant extends Tier {
2
3 public Elefant () {
4 super ();
5 }
6
7 public void laufe (){
8 System . out . println (" stampfe " );
9 }
10 }
54

Listing 7: Die Klasse Maus
1 public class Maus extends Tier {
2
3 public Maus () {
4 super ();
5 }
6
7 public void laufe (){
8 System . out . println (" tripple " );
9 }
10 }
Wie man sieht, haben diese Tiere eine Eigene Version der Methode
laufen(). Sie überschreiben oder Überlagern die Methode der Vaterklasse.
Von der Vaterklasse erben die beiden Kindklassen jedoch eine Menge:
• die Variable alter
• die Methoden printAlter() und setAlter()
• den Konstruktor von Tier, der mit Hilfe des Befehls super() aufgerufen
wird
• die Möglichkeit, auch die alte Methode laufen() zu nutzen, indem
man einfach den Befehl super. davorhängt (super.laufen).
Die Vererbung wird eingeleitet, indem man in der Klassensignatur nach
dem Klassennamen den Befehl extends anfügt und danach den Namen
der Vaterklasse angibt. Jede Klasse kann übrigens nur einen Vater haben,
man spricht auch von Einfachvererbung.
Es gibt übrigens einen weiteren neuen Befehl in der Klasse Tier, nämlich
den Befehl this, mit dem man aus einer Methode heraus auf die
globale Variable zugreifen kann. Schaut euch dazu einmal die Methode
setAlter() genauer an. Hier wird beim Aufruf ein Parameter gefordert
mit Namen alter , der als lokale Variable dient und genau so benannt ist,
wie die globale Variable, diese also ebenfalls überläd. Durch den Befehl
this. kann jedch auf die globale Variable zugegrien werden und man
kann ihr so den Wert des Parameters zuweisen.
55

Wissenssicherung
Um sicherzustellen, dass du verstanden hast, welcher Grundgedanke
hinter der Vererbung steckt, überlege einmal genauer, warum es in Java
nicht möglich ist, von zwei Vaterklassen direkt zu erben. Stelle dir dabei
vor, welche Schwierigkeiten auftreten könnten, wenn man Mehrfachvererbung
zulieÿe.
Information
8.1.2. Vererbung in Greenfoot
Auch Greenfoot nutzt Vererbung. Wenn man sich die Klasse Wombat einmal
anschaut, dann fällt einem sofort auf, dass sie von der Klasse Actor
erbt. Dass soll sie, damit die Welt sicher gehen kann, dass jeder Wombat
eine act()-Methode vorzuweisen hat. Diese wird dann im Wombat selber
überlagert und mit dem Verhalten des Wombats gefüttert. Vererbung
ist also auch eine Möglchkeit, um Sicherzustellen, dass ein Objekt einer
(Kinde-)Klasse eine bestimmte Methode aufweist.
56

Information
8.1.3. Vererbung in Klassendiagrammen
Die Vererbung läÿt sich übrigens wunderbar in Klassendiagrammen darstellen.
Hier einmal ein kleiner Beispiel 9 :
Verebung wird in UML Klassendiagrammen mittels leerer Pfeile dargestellt.
Abbildung 16: Vererbung in Klassendiagrammen
9 Quelle: http : //www.rolandgeyer.at/kurse/media/bild j ava/b7.gif
57

Aufgabe
Erzeuge die zu Abbildung 16 auf Seite 57 passenden Klassen Person,
Erwerbstätigund Unbeschäftigt.
Jede Klasse soll neben den angegebenen Parametern auch folgende Methoden
haben:
• Die Klasse Person bekommt eine Methode telefoniere().
• Die Klasse Unbeschäftigt bekommt eine eigen Methode telefoniere(),
sowie eine Methode sitzeBeimAmt().
• Die Klasse Erwerbstätig bekommt eine eigen Methode geheArbeiten().
Frage: Objekte welcher Klasse können telefonieren, welche können arbeiten
gehen.
58

8.2. Interfaces
Information
Vor allem beim verteilten Programmieren ist es wichtig, gewisse Schnittstellen,
auf Englisch Interfaces zu vereinbaren. Ein Interface ist dabei keine
Klasse, die in Methoden beschreibt, wie man etwas tut, sondern nur eine
Sammlung von Methodensignaturen, die zwingend von einer Methode mit
Leben zu füllen (zu implementieren) sind. Ein Interface schreibt also nur
vor, welche Methoden vorhanden sein sollen, nicht aber, wie sie funktionieren.
Warum aber will man nun interfaces haben, reicht nicht Vererbung?
Leider nicht, denn Java läÿt keine direkte Mehrfachvererbung zu. Interfaces
hingegen kann man beliebig viele implementieren und somit mehrere
Vereinbarungen erfüllen. Wie genau Interfaces eingesetzt werden, werden
wir spätestens dann besprechen, wenn es um den Listener-Mechanismus
geht. Bis dahin musst du dich mit folgendem kleinen Beispiel zufrieden
geben.
Listing 8: Das Interface Essbar
1 /**
2 * Dieses Interface zeigt an,
3 * dass ein Gegenstand essbar ist
4 */
5 public interface Essbar {
6
7 public void issMich (); // Nur Methodensignatur!
8
9 }
59

Listing 9: Das Interface Trinkbar
1 /**
2 * Dieses Interface zeigt an,
3 * dass ein Gegenstand trinkbar ist
4 */
5 public interface Trinkbar {
6
7 public void trinkMich (); // Nur Methodensignatur!
8
9 }
Listing 10: Und Jetzt die Suppe ...
1 public class Suppe implements Essbar , Trinkbar {
2
3 public void issMich (){ // Muss implementiert werden!
4 System . out . println (" Hmm , ein wenig dünn ... " );
5 }
6
7 public void trinkMich (){ // Muss implementiert werden!
8 System . out . println (" Schlürf ... " );
9 }
10 }
60

8.2.1. Interfaces in UML
Hier noch eine kleine Information zur Darstellung von Interfaces in UML-
Klassendiagrammen. Die Implementierung wird durch einen gestrichelten
Pfeil mit leerer Spitze dargestellt. Interfaces können von anderen Interfaces
erben, beim Implementieren muss man dann die Methoden aller
Interfaces füllen.
Abbildung 17: Interfaces und Klassendiagramme
Leere Pfeile zeigen an, dass eine Klasse ein Interface implementiert.
61

8.3. Aufgabe
Gegeben ist die Klasse Fahrzeug.
1 public class Fahrzeug {
2 int anzahlRäder ;
3 int anzahlSitzplätze ;
4
5 boolean kannFahren = false ;
6
Listing 11: Die Klasse Fahrzeug
7 public void fahreLos (){
8 if ( kannFahren )
9 System . out . println (" Ich fahre los " );
10 }
11 }
Erstellt die Klassen Fahrrad und Auto, die von Fahrzeug erben und die
Variablen geeignet belegen. Schreibe auch eine Methode starteMotor(),
die das Auto in einen fahrtüchtigen Modus versetzt. Überlege dir dann
eine entsprechende Methode für das Fahrrad. Als Letztes überlege, ob du
eine sinnvolle Erweiterung von Auto, also eine Klasse, die von Auto erbt,
ndest und implementiere diese.
62

8.4. instanceof - Exkursion
Mit Hilfe des Befehles instanceof kann man zur Laufzeit überprüfen, ob
Objekt Instanz einer Klasse ist. Nehmen wir einmal das folgende Beispiel:
Es gibt eine Klasse Auto, sowie zwei Klassen Cabrio und Geländewagen,
welche Auto erweritern. Jetzt kann ein Cabrio sein Verdeck auf
und zu fahren (fahreAuf() und fahreZu()), ein Geländewagen hingegen
hat die Möglichkeit, Allrad zuzuschalten (setAllrad(boolean zustand)).
Jedes Auto kann hupen (hupe()). Schau dir nun den folgenden Quellcode
an und überlege, was beim Aufrufen der Methode dreAutos() geschieht.
Listing 12: Neulich in der Waschstraÿe
1 public class Waschstrassentest {
2
3 private Auto meinAuto ;
4 private Cabro meinCabrio ;
5 private Gelaendewagen meinOffroader ;
6
7 public Waschstrassentest (){
8 meinAuto = new Auto ();
9 meinCabrio = new Cabrio ();
10 meinOffroader = new Gelaendewagen ();
11
12 wasche ( meinAuto );
13 wasche ( meinCabrio );
14 wasche ( meinOffroader );
15 }
16
17 public void wasche ( Auto auto ){
18 if ( auto instanceof Cabrio )
19 fahreZu ();
20 else if ( auto instanceof Gelandewagen )
21 setAllrad ( false );
22 hupe ();
23 }
24
25 }
Überlege dann, ob es sinvoll wäre, Cabrio und Gelaendewagen als Interfaces
zu denieren.
63

8.5. Lernkontrolle
Lernkontrolle
Ich kenne jetzt:
• die Vererbungsidee
• den Befehl extends, welcher die Vererbung einleitet
• den Befehl this zum Reerenzieren überladener globaler Variablen
• den Befehl super zum Reerenzieren der Vaterklasse
• den Interface-Gedanken
• die Darstellung von Vererbung und Implementation in UML
Wenn du dir sicher genug bist, mache den Kapiteltest.
8.6. Kapiteltest
Kapiteltest
Der Kapiteltest für dieses Kapitel wird in Einzelarbeit absolviert.
64

9. Kapitel VII - Weitere Fähigkeiten von Greenfoot
Übersicht
In diesem letzten Kapitel wirst du eine Reihe weiterere Möglichkeiten
kennen lernen, die dir Greenfoot im Umgang mit Java liefert. Dabei
musst du nicht alles lesen, viel mehr ist dieses Kapitel eine Sammlung von
Exkursionen, die du bei Interesse lesen kannst. Am Ende kannst du deine
Ideen in einem kleinen Spiel umsetzen.
Viele der Features von Greenfoot hast du vielleicht schon selber angetestet.
Wenn du noch etwas hast, was hier fehlt, dann schreibe es auf und lass es
ein Teil des Leitprogramms werden.
Lernziele
In diesem Kapitel wirst du folgendes kennenlernen:
• Ändern der Bilder eines Actors
• Greenfoot und Sounds
• Steuern des Actors mit Tastatur und Maus
• Zufällige Werte
• Kombination zu einem eigenen Spiel.
65

9.1. Bilder austauschen mit setImage()
Jedes Actor-Objekt in Greenfoot kennt die Methode void setImage(String
lename) . Diese vererbt er auch an alle Kindklassen. Der Parameter ist
eine Zeichenkette und beschreibt, wo ein Bild zu nden ist und welchen
Namen es hat (z.B. meinbild.gif). Die Methode ändert das Bild des Objektes.
Am besten ist es, wenn das Bild mit im Objektordner gespeichert
ist.
Ein Beispiel:
1 Act () {
2 if ( canMove ())
3 {
4 move ();
5 }
6 else
7 {
8 setImage (" rock . gif " );
9 }
10 }
Listing 13: Der Wombat verkleidet sich als Stein
Passend zum Setter gibt es übrigens auch die Methode getImage(),
welche ein Objetkt vom Typ GreenFootImage zurückliefert.
9.2. Neue Objekte in die Welt einfügen
Neben der Klasse Actor, die noch einige weitere nützliche Methoden bereitstellt,
gibt es die Klasse World, die ebenfalls interessante Möglichkeiten
erönet.
Zwei wichtige Methoden sind void addObject(Actor object, int
x, int y) und void removeObject(Actor object). Die erste fügt der
Welt eine Instanz der Actor-Klasse an der stelle (x|y) hinzu, die zweite
löscht ein Objekt. Somit lassen sich neue Objekte ganz einfach in der Welt
positionieren oder bestehende Objekte entfernen.
Ein Beispiel für removeObject() ndest du in der eatLeaf-Methode. Nach
der folgenden Anpassung erzeugt der Wombat nun an der Stelle, wo er
ein Blatt ist, einen Stein.
66

Listing 14: Der Wombat macht einen Stein
1 public void eatLeaf ()
2 {
3 Actor leaf = getOneObjectAtOffset (0 , 0, Leaf . class );
4 if ( leaf != null ) {
5 // eat the leaf...
6 getWorld (). removeObject ( leaf );
7 getWorld (). addObject ( new Rock ());
8 leavesEaten = leavesEaten + 1;
9 }
10 }
Ach ja, richtig, damit der Wombat einen Stein erzeugen kann, muss er
die Methode seiner Welt aufrufen. Ja, jeder Actor kann sich die Welt, in
der er lebt, mit der Methode getWorld() holen und dann direkt die Methoden
der Welt nutzen. Klingt kompliziert, ist aber nach etwas Eingewöhnung
ganz einfach!
9.3. Hast du Töne
Greenfoot kann auch einfach Töne abspielen. Hierzu gibt es die Methode
Greenfoot.playSound(sound.wav);. Neu ist, dass die Methode
direkt aus der Klasse Greenfoot aufgerufen wird. Man benötigt kein
Objekt dafür. Eine solche Methode wird statisch, auf Englisch static
genannt. Greenfoot spielt übrigens nur Dateien im wav- oder aif-Format,
keine mp3-Dateien.
9.4. Input und Output per Tastatur
Hier lernst du etwas über das Steuern eines Actors per Maus oder Tastatur.
Es gibt zwei Möglichkeiten, einen Actor mit der Tastatur zu steuern.
Einmal das andauernde Drücken einer Taste, zum andern das kurze Antippen.
Beide Methoden werden hier beschrieben.
9.4.1. Andauerndes Drücken
Die Klasse Greenfoot bietet weitere statische Methoden, eine ist die Methode
Greenfoot.isKeyDown(). Ein Actor kann diese Methode aufrufen
und als Parameter den Namen der Taste übergeben, deren Status er abfragen
will. Wenn die Taste im Moment gedrückt ist, dann liefert die Methode
den Wert true zurück. Hier ein kleines Beispiel:
67

Listing 15: Steuern des Wombat I
1 if ( Greenfoot . isKeyDown (" left " )) {
2 turnLeft ();
3 }
4 else if ( Greenfoot . isKeyDown ("m" )){
5 move ();
6 }
9.4.2. Kurzes Antippen
Um nur ein kurzes Tippen abzufragen, gibt es die Methode getKey(),
ebenfalls in der Greenfoot Klasse. Sie gibt an, welche Taste als letztes
gedrückt wurde, auch wenn jetzt gerade keine Taste gedrückt ist.
Listing 16: Steuern des Wombat II
1 if ( Greenfoot . getKey (). equals ("m" )){
2 move ();
3 }
Neu ist übrigens die Methode equals(). Diese gehört zur Klasse String
und kann hier benutzt werden, weil die Methode getKey() einen String
zurückgibt. Diese Verschachtelung von Methoden wird dir noch häuger
begegnen. Es ist übrigens Sinnvoll, Strings mit der equals()-Methode und
nicht mit == zu vergleichen, da Strings Objekte sind und der Vergleich
mit == nur dann true lifert, wenn es sich um genau die selben Objekte
(und nicht Objekte mit selbem Inhalt) handelt.
9.4.3. Ein weiters Beispiel (Funken)
Steuern des Wombat per Tastatur:
Beispielsweise wollen wir erreichen, dass sich unser Wombat bei jedem
Drücken der linken Pfeiltaste nach links dreht, dann lautet der Quellcode
dafür:
Listing 17: Steuern des Wombat III
1 if ( Greenfoot . isKeyDown (? left ?)) {
2 turnLeft ();
3 }
Also lautet der gesamte Quellcode, um den Wombat mit den Pfeiltasten
zu steuern:
68

1 public void act (){
2
Listing 18: Steuern des Wombat III
3 if ( Greenfoot . isKeyDown (" up " )){
4 move ();
5 }
6 else if ( Greenfoot . isKeyDown (" down " )){
7 moveBack ();
8 }
9 else if ( Greenfoot . isKeyDown (" left " )){
10 turnLeft ();
11 }
12 else if ( Greenfoot . isKeyDown (" right " )){
13 turnRight ();
14 }
15 }
9.5. Input und Output per Maus
Die Eingabe per Maus ist etwas komplizierter, wird jedoch relativ gut in
der (englischen) Hilfe erläuter. Hier ein Link auf die entsprechende Seite:
http://www.greenfoot.org/doc/manual.html#mouse
9.6. Zufall und Zufallswerte
Zufällige Bewegungen in Greenfoot machen das Spielen erst richtig interessant.
Sie basieren auf zufälligen Werten, sogenannten Zufallszahlen (eng.
random numbers, kurz random). Solche Zahlen zu erzeugen ist recht einfach.
Die Klasse Greenfoot hat auch hierfür eine entsprechende Methode,
public int getRandomNumber(int limit). Diese Methode erzeugt
eine ganzzahlige Zufallszahl zwischen den werten 0 und dem übergebenen
Limit (exklusive).
Hier ein kleines Beispiel:
Listing 19: Der Wombat wirft eine Münze
1 if ( Greenfoot . getRandomNumber (2) == 0) { // 50% chance
2 turnLeft ();
3 }
4 else {
5 turnRight ();
69

6 }
9.7. Und wie nun weiter?
Lernziele
Überlege dir mit deinem Partner ein kleines Spiel. Nutze hierfür entweder
die vorgegebenen Klassen und verändere sie, oder schreibe neue Klassen
dazu. Gebraucht dabei die in diesem Kapitel vorgestellten Möglichkeiten
von Greenfoot.
70

10. Ende
Damit endet dieses Leitprogramm. Du solltest jetzt in der Lage sein, einfache
Java-Programme zu lesen und Algorithmen in dieser Sprache zu
implementieren. Wir werden im Unterricht noch ein wenig mit Greenfoot
weiterarbeiten, uns jedoch bald mit einem anderen Editor auseinandersetzen.
Ich hoe, das Lesen und Durcharbeiten des Leitprogramms hat dir Spaÿ
gemacht und würde mich über ein Feedback freuen, also fülle bitte den
folgenden Fragebofen aus und gib ihn ab, damit ich das Leitprogramm
für die kommenden Kurse verbessern kann.
Danke
10.1. Fragebogen
Im Folgenden kannst du die Nützlichkeit und Benutzbarkeit dieses Leitprogrammes
für dich einschätzen und deine Meinung äuÿern. Bitte nimm
dir ein paar Minuten Zeit, denn so kann ich das Leitprogramm für die
folgenden Generationen von Schülern erweitern und anpassen.
Danke schon einmal im Voraus!
10.1.1. Benutzbarkeit
Bitte vergib hinter jedem aufgeführten Punkte eine Note von 1 (sehr gut)
bis 6 (ungenügend).
• Die Aufteilung der Kapitel (Übersicht, Lernziele, Informationen, Aufgaben)
helfen beim Erarbeiten der Informationen.
• Der Aufbau des Leitprogramms war übersichtlich.
• Die abschlieÿenden Kapiteltests helfen beim Einschätzen der eigenen
Lernleistung.
• Die Arbeit mit dem Leitprogramm ermöglicht ein eigenständiges Lernen.
• Die Arbeit mit dem Leitprogramm macht Spaÿ.
71

Anmerkungen:
10.1.2. Inhalte
Bitte vergib hinter jedem aufgeführten Punkte eine Note von 1 (sehr gut)
bis 6 (ungenügend).
• Die Inhalte der einzelnen Kapitel waren für mich leicht verständlich.
• Neue Konzepte wurden genügend tief besprochen und durch Beispiele
verdeutlicht.
• Auf Inhalte der vorangehenden Kapitel wurde Bezug genommen.
Anmerkungen:
10.1.3. Lernzuwachs
Bitte vergib hinter jedem aufgeführten Punkte eine Note von 1 (sehr gut)
bis 6 (ungenügend).
• Ich habe eine Reihe neuer Dinge über das Programmieren am Computer
gelernt.
• Ich habe die Grundlagen der objektorientierten Programmierung verstanden.
• Ich kenne nun einige Möglichkeiten, um in Zukunft auftretende Probleme
beim Programmieren eigenständig zu lösen.
Anmerkungen:
10.1.4. Verbesserungsvorschläge und Ideen
Hier kannst du eigene Ideen und Verbesserungsvorschläge als Text schreiben.
72

11. Ein Dankeschön
Ein besonderes Dankeschön geht an die Grundkurse Informatik Q im
Jahrgang 2010/2011, besonders an die folgenden Schüler:
• Dietrich für den Teil zu setImage
• Funken für den Teil zur Tastatursteuerung
• Schäuble, Freier u.A. für ihr eiÿiges Korrekturlesen
73

A. Installation von Java und Greenfoot
A.1. Java installieren
Ladet euch unter java.sun.com das aktuelle JDK (Java Developement
Toolkit) herunter. Das momentan aktuelle Java 6 bekommt ihr unter:
java.sun.com
Die Installation von Java funktioniert voll automatisch, folgt nur den
Anweisungen auf dem Bildschirm.
A.2. Greenfoot installieren
Ladet euch dann Greenfoot herunter, ihr ndet es unter:
www.greenfoot.org
Die Installation funktioniert ebenfalls wie gewohnt. Nun sollte es ein
neues Menü und ein Icon auf eurem Desktop geben.
A.3. Erweiterte Inhalte
Ihr bekommt im Laufe der Unterrichtsreihe auÿerdem einen Link auf weitere
Greenfoot Szenarion. Die Installation ist einfach:
• Das Zip-Archiv wird in einem neuen Ordner abgelegt.
• Merke dir diesen Ordner, um die Dateien später zu nden.
74

B. Benutzung des Leitprogramms
B.1. Einführung
Mit diesem Leitprogramm machst du eigenständig erste Gehversuche in
der Programmiersprache Java. Du arbeitest dabei entweder alleine oder
mit einem festen Partner, wobei jeder das Leitprogramm durcharbeiten
soll.
Das Leitprogramm ist in Kapitel aufgeteilt, die alle vollständig und in
der richtigen Reihenfolge bearbeitet werden müssen. Auÿerdem gibt es
Exkursionen, die dich entweder mit weiteren interessanten Informationen
zum Thema versorgen oder dir als Wiederholung / Aurischung dienen
können.
Am Ende eines jeden Kapitels erfolgt eine Abprüfung des Gelernten
mittels Kapiteltest (entweder unbewerteter oder bewerteter Test).
B.1.1. Arbeitsanleitung
Zuerst wird jeweils ein Kapitel selbständig mit deinem Partner abgeschlossen.
Hierbei lest ihr zuerst die neuen Informationen durch und setzt sie nachher
in euren Programmen um.
Anschlieÿend werdet ihr einzeln einen kleinen Kapiteltest machen, welcher
euch vom Lehrer gegeben wird.
Fragen
• Muss das ganze Leitprogramm bearbeitet werden? - Einige der Informationsabschnitte
und Aufgaben sind als "Freiwillig" gekennzeichnet
und müssen im Rahmen des Leitprogramms nicht bearbeitet werden.
Sie bieten schnelleren Gruppen die Möglichkeit, sich tiefer zu einem
Thema zu informieren und ihre Seite schöner zu gestalten.
Auÿerdem sind die Exkursionen freiwillig, denn ihre Inhalte gehen
75

entweder über den Unterrichtssto hinaus oder werden in der Gruppe
besprochen.
• Was tue ich bei Fragen zum Thema? - Solltest du einen Abschnitt
auch nach gründlichem Durchlesen nicht verstehen, so fragst du zuerst
deinen Partner. Sollte auch er dir nicht weiter helfen können, dann
fragt gemeinsam eine Kameradin oder einen Kameraden. Denkt daran,
dass dieser eventuell selber gerade beschäftigt ist und unterbrecht ihn
nicht abrupt.
Falls ihr auch zu dritt nicht weiter kommt, dürft ihr gerne den Lehrer
oder die Lehrerin fragen.
76

B.1.2. Zeichenerklärung:
Die einzelnen Kapitel sind immer wie folgt strukturiert:
• Übersicht: Was wird in diesem Kapitel behandelt und was gibt es zu
tun?
Abbildung 18: Übersicht
• Lernziele: Was kann ich nach dem Bearbeiten des Kapitels?
Abbildung 19: Lernziele
• Inhalte: Neuer Sto wird vorgestellt. Im Teil mit dem eigentlichen
Lernsto trist du auf die folgenden Zeichen:
Denition: Hier wird etwas deniert. Diese Denitionen sind
wichtig und müssen auswendig gelernt werden!
Information: Hier stehen Informationen im Text, die Inhalt der
aktuellen Lerneinheit sind.
Wissenssicherung: Hier wird noch einmal kurz das zu Erlernende
an Beispielen wiederholt.
Aufgabe: Kleine Aufgaben zum Erproben des neu Gelernten.
• Lernkontrolle: Habe ich alles verstanden? Lösungen zu den gestellten
Problemen.
• Kapiteltest: Nach der Lernkontrolle kannst du dich für den Kapiteltest
melden.
77

Abbildung 20: Symbole zum Lerninhalt
Abbildung 21: Lernkontrolle
Abbildung 22: Kapiteltest
78

C. Verzeichnisse
C.1. Bilderverzeichnis
Abbildungsverzeichnis
1. Greenfoot - So sieht es aus ... . . . . . . . . . . . . . . . . 6
2. Ein Wombat auf der Welt . . . . . . . . . . . . . . . . . 18
3. Start und Stop . . . . . . . . . . . . . . . . . . . . . . . . 23
4. Ein- und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . 24
5. Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6. Bedingte Verzweigung . . . . . . . . . . . . . . . . . . . . 25
7. Subprogramm . . . . . . . . . . . . . . . . . . . . . . . . . 25
8. Addition über Inkrement und Dekrement . . . . . . . . . . 26
9. Ein Algorithmus zum Vergleichen von zwei Zahlen . . . . . 27
10. Eine Beispielbelegungstabelle . . . . . . . . . . . . . . . . 28
11. Was tut dieser Algorithmus? . . . . . . . . . . . . . . . . . 29
12. JavaDoc erzeugt schöne Methodenbeschreibungen . . . . . 33
13. Ein weiterer unbekannter . . . . . . . . . . . . . . . . . . . 42
14. Klassendiagramm Wombat . . . . . . . . . . . . . . . . . . 47
15. Ein einfaches Klassendiagramm . . . . . . . . . . . . . . . 49
16. Vererbung in Klassendiagrammen . . . . . . . . . . . . . . 57
17. Interfaces und Klassendiagramme . . . . . . . . . . . . . . 61
18. Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
19. Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
20. Symbole zum Lerninhalt . . . . . . . . . . . . . . . . . . . 78
21. Lernkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . 78
22. Kapiteltest . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
C.2. Listingverzeichnis
Listings
1. Die Act-Methode des Wombat . . . . . . . . . . . . . . . . 20
2. Die Methode act() . . . . . . . . . . . . . . . . . . . . . . 31
3. Addieren von zwei Zahlen . . . . . . . . . . . . . . . . . . 33
4. Eine kleine Verhaltensregel ... . . . . . . . . . . . . . . . . 35
5. Die Klasse Tier . . . . . . . . . . . . . . . . . . . . . . . . 54
6. Die Klasse Elefant . . . . . . . . . . . . . . . . . . . . . . 54
79

7. Die Klasse Maus . . . . . . . . . . . . . . . . . . . . . . . 55
8. Das Interface Essbar . . . . . . . . . . . . . . . . . . . . . 59
9. Das Interface Trinkbar . . . . . . . . . . . . . . . . . . . . 60
10. Und Jetzt die Suppe ... . . . . . . . . . . . . . . . . . . . . 60
11. Die Klasse Fahrzeug . . . . . . . . . . . . . . . . . . . . . 62
12. Neulich in der Waschstraÿe . . . . . . . . . . . . . . . . . . 63
13. Der Wombat verkleidet sich als Stein . . . . . . . . . . . . 66
14. Der Wombat macht einen Stein . . . . . . . . . . . . . . . 67
15. Steuern des Wombat I . . . . . . . . . . . . . . . . . . . . 68
16. Steuern des Wombat II . . . . . . . . . . . . . . . . . . . . 68
17. Steuern des Wombat III . . . . . . . . . . . . . . . . . . . 68
18. Steuern des Wombat III . . . . . . . . . . . . . . . . . . . 69
19. Der Wombat wirft eine Münze . . . . . . . . . . . . . . . . 69
80