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.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.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.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.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.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.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


Lernkontrolle 




• die einzelnen Methoden des Wombat und kann sie benutzen, um den 

Wombat zu steuern 

• die Methode act() und kann das Verhalten des Wombat deuten 



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 


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 


• 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 { 


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


Lernkontrolle 




• 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. 


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 


• 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 


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. 


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


Lernkontrolle 




• Die genaue Denition des Algorithmusbegris 

• Ein sinnvolles Vorgehen zum Lösen von Programmierproblemen 



Kapiteltest 


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 


• 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. 


Lernkontrolle 




• Die UML Notation für Klassendiagrammen 

• Die Java API, suchen und nden von Informationen 


50


Kapiteltest 


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 


• 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 


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 


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


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


Lernkontrolle 


• 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 



Kapiteltest 


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 


• Ä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 " )) { 


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 ?)) { 


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 " )){ 


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 


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 



• 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 



• 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

Das Java Leitprogramm

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?