Document

1
Frosch-Welt analysieren und verwenden............................................................................1
1.1
Szenario öffnen...........................................................................................................1
1.2
Frosch-Welt bevölkern................................................................................................2
1.3
Frösche und Fliegen agieren lassen............................................................................2
1.4
Untersuchungen mit dem Inspector............................................................................3
1.5
Quellcode editieren.....................................................................................................4
2
Ein Szenario verändern oder erweitern...............................................................................6
2.1
Objekte einer weiteren Klasse hinzufügen.................................................................6
2.2
Auch Frösche können lernen – neue Methoden (mit und ohne Rückgabe)Algorithmik.............................................................................................................................6
2.2.1
Sequenzen - Methoden und Konstruktoren.........................................................6
2.2.2
Wiederholungen und Entscheidungen................................................................7
2.2.3
Variablen – Langzeit- und Kurzzeitgedächtnis...................................................8
2.2.4
Zählschleifen.......................................................................................................9
2.2.5
Methoden mit Parameter.....................................................................................9
2.3
Verwendung von Methoden der Klasse Greenfoot um Benutzerinteraktionen zu
ermöglichen..........................................................................................................................10
3
Eigene Szenarien erstellen................................................................................................12
Greenfoot
1 Frosch-Welt analysieren und verwenden
1.1 Szenario öffnen
Wählen Sie das Szenario „Frosch“ aus und öffnen Sie es.
Vorsicht beim Speichern: Vorsicht beim Speichern: Bei der standalone-Version wird der
gesamte Ordnername angezeigt.
24.08.2015
1
1.2 Frosch-Welt bevölkern
Falls nach dem Öffnen im Fenster noch keine Welt
zu sehen ist, kann man Sie aus zwei verschiedenen
Arten erzeugen: Durch Klicken auf die Schaltfläche
„Compile All“ oder indem man mit der rechten
Maustaste rechts auf „FroschWelt“ klickt und
anschließend „new FroschWelt()“ auswählt.
Um die Welt mit Fröschen zu bevölkern, klickt man
mit der rechten Maustaste auf „new Frosch()“ und
positioniert den Frosch dann irgendwo in der Welt.
Entsprechend können Fliegen erzeugt und in der Welt
positioniert werden.
Aufgabe 1:
Laden Sie das Szenario „FroschVorlageAufgabe1“.
Erzeugen Sie eine Welt und bevölkern Sie sie
entsprechend der folgenden Abbildung.
1.3 Frösche und Fliegen agieren lassen
Mit einen rechten Mausklick auf einen Frosch, kann man sich die Methoden anzeigen
lassen, die er ausführen kann.
24.08.2015
2
Dies sind die Methoden von Fröschen sowie die Methoden der Oberklassen Actor und
Object. (Denn Frösche sind spezielle (Objekte der Klasse) Actor und damit auch (der
Klasse) Object. Da alle Objekte der Klasse Actor z.B. über die Methode void
setLocation(int,int) verfügen, verfügt auch ein Frosch darüber.)
Aufgabe 2:
a) Laden Sie das Szenario „FroschVorlageAufgabe2“. Fragen Sie den Frosch in
der linken unteren Ecke, ob vor ihm ein freies Feld ist, lassen Sie ihn sich
nach links drehen, einen Schritt vorwärts hüpfen, und fragen Sie ihn, wie viel
Fliegen er gefressen hat. Anschließend soll er sich so drehen, dass er Richtung
Osten blickt. (Osten entspricht hierbei der Richtung 0). Danach soll er wieder
einen Schritt vorwärts hüpfen. Rufen Sie dazu jeweils die entsprechende
Methode des Froschs auf. Klicken Sie dazu mit der rechten Maustaste auf den
Frosch.
Achtung: Probleme kann es geben, wenn sich auf einem Feld zwei Akteure
befinden. Ggf. dann nur einer der Akteure mit Hilfe der rechten Maustaste
erreicht werden (wie hier die Fliege, auf der der Frosch sitzt).
(Vorrangregelung nach der Reihenfolge, in der die Objekte auf das Feld
gekommen sind!)
b) Klicken Sie drei mal hintereinander auf die Schaltfläche „Act“, anschließend
auf die Schaltfläche „Run“ und dann auf „Pause“.
1.4 Untersuchungen mit dem Inspector
Aufgabe 3:
Untersuchen Sie nachdem Sie Aufgabe 2 ausgeführt haben die Frösche und eineFliege,
indem Sie sie mit der rechten Maustaste anklicken und „Inspect“ auswählen. Ermitteln
Sie welcher Frosch am meisten Fliegen gefressen hat.
24.08.2015
3
Alle Frösche haben die gleichen Methoden und die gleichen Attribute. Lediglich die
Namen frosch, frosch 2,…und die Attributwerte sind unterschiedlich. Die
einzelnen Frosch-Objekte frosch, frosch 2, …gehören daher alle zur Klasse
Frosch.
Frosch
-richtung : int
-vertilgteFliegen: int
+act(): void
+dreheLinks(): void
+fliegeGefunden(): boolean
+frissFliege():void
+getAnzahlVertilgterFliegen(): int
+huepf(): void
+setzeRichtung(int): void
+vorneFrei(): boolean
(Die weiteren Attribute wurden hier nicht angegeben, weil sie von der Klasse Actor
geerbt wurden. – Die Fliegen haben diese Attribute ebenfalls von der Klasse Actor
geerbt.)
Aufgabe 4:
Öffnen Sie das Szenario Spinnen, übersetzen Sie es erneut (mit „Compile All“),
erzeugen Sie eine Spinne, untersuchen Sie sie und zeichnen Sie dann ein
Implementationsdiagramm der Klase Spinne.
Quelle für das Spinnenszenario:
http://bildungsserver.berlin-brandenburg.de/unterricht/faecher/mathematiknaturwissenschaften/informatik/material-inf/prog-sprachen/inf-pspr-bluej/infgreenfoot1/?L=0, abgerufen am 21.08.2015
1.5 Quellcode editieren
Mit einem Doppelklick auf eine Klasse öffnet sich der integrierte Java-Editor.
Einige Hinweise zur Arbeit mit Java:
Eine Java-Klasse hat in der Regel folgende Form:
import <benötigte Klassenbibliotheken>;
class <Klassenname> {
// Variablen für Objekte oder Daten:
// Objekte:
<public oder private> <Klassenname> <Objektname(n)>;
//Daten:
<public oder private> <Datentyp> <Variablenname>;
. . .
// Methoden:
<public oder private> void <Methodenname> (… ) {
//Aufrufe in der Form:
<objektname>.<methodenname(…)>;
//oder Zuweisungen der Form :
<Variablenname>=<Wert>;
//oder Erzeugung eines Objekts:
<Objektname>=new <Klassenname>();
24.08.2015
4
};
// Ende der Methode
...
} //Ende der Klasse
-
-
-
-
-
-
Programmblöcke, Methoden und Klassendefinitionen beginnen und enden mit
geschweiften Klammern {}. Einrückungen und Kommentare erleichtern das
Lesen. (/*<Kommentar>*/ oder //<Kommentar bis zum Zeilenende>)
Kommentare für die Dokumentation einer Methode werden mit
/ /**
* Kommentar
*/
vor die Methode geschrieben.
Groß- und Kleinschreibung beachten: Methodennamen und Attribute beginnen
in der Regel mit kleinem Buchstaben, Klassennamen mit großem Buchstaben.
In Klassendefinitionen werden zunächst die Variablen definiert, dann die
Methoden.
Am Anfang steht jeweils der Typ, z.B. int. void bedeutet dabei, dass die
Methode keinen Wert zurückgibt.
private kennzeichnet Variablen (Attribute) und Methoden, die nur innerhalb
dieser Klasse verwendet werden dürfen. public sind Methoden, die auch von
außen aufgerufen werden dürfen.
Soll eine Methode eines anderen Objekts aufgerufen werden, so steht dessen
Name vor dem Methodennamen. Zwischen Methodennamen und Objektnamen
steht ein Punkt. (<Objekt>.<Methode>(…);) Um eine eigene Methode des
Objekts aufzurufen, kann der Adressat entfallen oder this als Adressat der
Nachricht angegeben werden. Um eine Methode, die aus einer Oberklasse (z.B.
Actor) geerbt wurde auszuführen, kann man statt einem Adressat super oder
this, wenn die Methode in der Unterklasse nicht überschrieben (d.h. neu
geschrieben) wurde oder gar nichts.
Methodenaufrufe und Methodennamen enden immer mit runden Klammern ().
Ggf. steht in diesen Werte. In diesem Fall müssen bei der Definition der
Methode der Typ der Werte und Nanen für die Werte in den runden Klammern
angegeben werden. (z.B. public void setzeRichtung(int wohin){…})
Methodenaufrufe und Variablendeklarationen werden mit Semikolon
abgeschlossen.
Bevor ein verändertes Programm gestartet werden kann, muss es (am besten
mit „Compile All“) in Maschinensprache übersetzt werden. Wenn es
erfolgreich übersetzt werden konnte, sind die grauen Balken über den
Klassennamen verschwunden.
…
Aufgabe 5:
Öffnen Sie das Szenario „FroschVorlageAufgabe5“.
Editieren Sie die Klassen Frosch und FroschWelt.
a) Ändern Sie FroschWelt so ab, dass sie automatisch bevölkert wird (durch Aufruf
der Methode populate() nach dem Setzen des Hintergrundbildes). Ändern sie auch
die Methode populate() so, dass FroschFranz an Position (1,2) noch hinzukommt.
b) Wenn Frösche sich nach Westen drehen, stehen sie auf dem Kopf. Dies soll nun
verändert werden durch Spiegelung des Bildes, das den Frosch repräsentiert, an der
entsprechenden Stelle in der Methode setzeRichtung(…). Nutzen Sie dazu die
Dokumentation der Klassen Actor und GreenfootImage der Greenfoot Class
24.08.2015
5
Documentation (API, engl.: application programming interface). Diese erreicht man
über einen Klick mit der rechten Maustaste auf Actor und der Auswahl von „Open
Documentation“.
2 Ein Szenario verändern oder erweitern
2.1 Objekte einer weiteren Klasse hinzufügen
Aufgabe 6:
Erzeugen Sie eine neue Unterklasse der Klasse Actor, von Hindernissen, wie Blumen
oder Felsen, die den Fröschen im Weg stehen können. Dazu können Sie mit der rechten
Maustaste auf die Klasse Actor klicken, „New subclass…“ auswählen und
anschließend in dem sich öffnenden Fenster den neuen Klassennamen angeben sowie ein
passendes Bild auswählen. Klicken Sie anschließend „Compile all“ an, um auch die neue
Klasse in Maschinensprache übersetzen zu lassen, und positionieren Sie eines dieser
neuen Objekte in der Welt.
2.2
2.2.1
Auch Frösche können lernen – neue Methoden (mit und ohne
Rückgabe)- Algorithmik
Sequenzen - Methoden und Konstruktoren
Wenn ein Frosch wenden soll, muss er sich zweimal nach links drehen. Wenn das
zweimalige Drehen mehrfach verwendet werden soll, lohnt es sich für die Klasse Frosch
eine neue Methode
public void wenden( ) {
dreheLinks();
dreheLinks();
}
zu schreiben.
Die neue Methode kann dann in anderen Methoden aufgerufen werden, z.b. in der
Methode act():
public void act(){
24.08.2015
6
}
…
wenden();
…
Das Wort void besagt hierbei, dass die Methoden nur Aktionen ausführen, jedoch
keine Antwort geben.
Im Gegensatz dazu liefern die Methoden vorneFrei(), fliegeGefunden() und
getAnzahlVertilgterFliegen() der Klasse Frosch Antworten. Der Typ der
Rückgabe wird bei der Methodendeklaration angegeben: int ist eine ganze Zahl,
boolean ein Wahrheitswert (true oder false). In Methoden mit Rückgabewert
muss das Schlüsselwort return vorkommen, hinter dem der zurückzugebende Wert
bzw. die Variable, deren Wert zurückgegeben werden soll anzugeben ist.
Konstruktoren sind Methoden , die automatisch bei Erzeugung eines Objekts
ausgeführt werden und sonst nie. Man erkennt sie daran, dass ihr Name mit dem der
Klasse übereinstimmt und kein Rückgabetyp angegeben ist (auch nicht void). Z.B.
public Frosch(){
setzeRichtung(0);
vertilgteFliegen = 0;
}
Mit super(…); wird der Konstruktor
der Oberklasse aufgerufen.
Aufgabe 7:
a) Schreiben Sie die Methoden dreiSchritteVor() und zweiSchritteVor()
für die Klasse Frosch. Testen Sie die Methoden.
Gehen Sie zur Vereinfachung davon aus, dass kein Hindernis (wie das Ende der
FroschWelt) im Weg ist.
b) Ein zaghafter Frosch hüpft immer erst drei Schritte vor (in seine momentane
Blickrichtung), frisst dort ggf. eine Fliege und hüpft dann wieder zwei Schritte
zurück. Am Ende soll seine Blickrichtung wieder wie am Anfang sein. Schreiben
Sie eine entsprechende Methode dreiVorZweiZurueck(). (Verwenden sie
dazu auch die Methoden aus Teilaufgabe a) und die Methode wenden().)
Testen Sie die neue Methode.
Gehen sie wieder zur Vereinfachung davon aus, dass kein Hindernis im Weg ist.
c) Schreiben Sie für die Klasse Frosch die Methode boolean fliegeRechts()
Gehen Sie der Einfachheit halber dabei davon aus, dass der Frosch nach Osten
blickt. Sehen sie sich dazu insbesondere die Methode fliegeGefunden() und
die Dokumentation der darin verwendeten Methoden an.
2.2.2
Wiederholungen und Entscheidungen
Manchmal sollen die Frösche nur unter bestimmten Bedingungen etwas tun.
Umgangssprachlich
Java
Allgemeine Java-Syntax
if(vorneFrei()){
if(<Bedingung>){
Wenn du vorwärts hüpfen
huepf();
<Anweisungen>
kannst, hüpfe ein Feld
}
}
weiter, sonst drehe dich
else {
else {
nach links.
dreheLinks();
<Anweisungen>
}
}
(Diese Syntax haben Sie vermutlich auch schon für Aufgabe 7c) verwendet.)
Oft wiederholen Frösche etwas, solange eine bestimmte Bedingung erfüllt ist.
Umgangssprachlich
Java
Allgemeine Java-Syntax
while(fliegeRechts()){
while(<Bedingung>){
Hüpfe vorwärts, solange
24.08.2015
7
rechts neben dir eine Fliege
}
ist.
huepf();
}
<Anweisungen>
Bedingungen können auch verknüpft werden: Das Und-Zeichen & steht für „und“, der
senkrechte Strich | für das mathematische „oder“, das Ausrufungszeichen ! für „nicht“.
Die einzelnen zu verknüpfenden Bedingungen sollten dabei in runde Klammern gesetzt
werden.
Zur Fallunterscheidung von mehreren Fällen, kann eine Konstruktion aus mehreren
geschachtelten if-else-Verzweigungen verwendet werden.
Falls es dabei um unterschiedliche Werte einer Variablen vom Typ int oder char
(Zeichen) geht, kann stattdessen abkürzend eine switch-Anweisung verwendet werden:
Umgangssprachlich Java
Allgemeine Java-Syntax
switch(richtung)
{
switch(<Variable>) {
Falls die Richtung
case 3 :
case <Wert1> :
„Süden“ (also 3) ist,
setRotation(90);
<Anweisung>
drehe um 90°, falls
break;
break;
die Richtung
case 0 :
case <Wert2> :
setRotation(0);
<Anweisung>
„Osten“ (also 0)ist,
break;
break;
…
}
case 1 :
setRotation(270);
break;
case 2 :
setRotation(180);
break;
.. .
}
Aufgabe 8:
a) Erzeugen Sie eine Welt, die der folgenden Abbildung
entspricht. Ändern Sie die Methode act() der Klasse
Frosch so ab, dass der Frosch sich nach Osten dreht und
dann so lange geradeaus geht, bis rechts neben ihm keine
Fliege mehr ist. Anschließend soll er sich hinter die letzte
Fliege stellen, wenden, der Reihe nach alle Fliegen
vertilgen und sich wieder nach Osten wenden. Testen Sie
die Methode. (Tipp: Nutzen Sie die Möglichkeit mit Hilfe
der rechten Maustaste einen einzelnen Frosch die
Methode act() ausführen zu lassen.)
Gehen Sie zur Vereinfachung davon aus, dass kein
Hindernis im Weg ist.
b) Ändern Sie die Methode huepf() so ab, dass der Frosch wenn er vor einer Fliege sitzt
zunächst einen Salto schlägt, bevor er ein Feld weiter hüpft.
Tipp: Mit einem zusätzlichen Objekt der Klasse Greenfoot, das in dieser Methode
erzeugt wird, kann man die Zeit verzögern, so dass man den Frosch hüpfen sieht:
Greenfoot gf=new Greenfoot();
…
gf.delay(20);
2.2.3
Variablen – Langzeit- und Kurzzeitgedächtnis
Frösche haben ein Gedächtnis. Sie können sich zum Beispiel merken, wie viele Fliegen
sie gefressen haben. Die Anzahl ist in der Variable vertilgteFliegen gespeichert.
Variablen müssen deklariert werden, dazu wird ihr Typ angegeben und entschieden, ob
sie private oder public sind, z.B. private int vertilgteFliegen;
24.08.2015
8
Werden Variablen am Klassenanfang (vor den Methodendeklarationen) deklariert, so ist
sie (beziehungsweise der Wert der Variablen) in jeder Methode verfügbar. Man nennt sie
globale Variablen. Wird eine Variable dagegen in einer Methode deklariert, so ist sie
nur so lange verfügbar, wie die Methode ausgeführt wird. Sie wird lokale Variable
genannt.
Variablen können Werte zugewiesen bekommen, z.B. vertilgteFliegen=0; .Mit dem
Gleichheitszeichen wird hier ein Wert zugewiesen. Will man dagegen einen Wert mit
einem anderen vergleichen (zum Beispiel in einer Bedingung), so benötigt man zwei
Gleicheitszeichen. (z.B. if(vertilgteFliegen==5){…}).
Oft wird in Java abkürzend Variablendeklaration und die erste Wertbelegung
zusammengefasst z.B. int vertilgteFlien=0;
Mit vertilgteFliegen=vertilgteFliegen+1; wird der Wert um 1 erhöht. (Der neue
Wert ist der alte Wert plus 1). Kurzform in Java: vertilgteFliegen++;)
Aufgabe 9:
a) Ein Frosch, der schon 10 Fliegen gefressen hat, ist satt und frisst nichts mehr.
Ändern Sie die Methode frissFliege() so ab, dass der Frosch nur dann frisst, wenn er
noch keine 10 Fliegen gefressen hat.
b) Die Frösche sollen sich merken, wie viele Sprünge sie (insgesamt) bereits gehüpft
sind. Die Anzahl soll mit Hilfe einer Methode gehuepfteSpruenge() erfragt werden
können.
2.2.4
Zählschleifen
Wenn man weiß, wie oft etwas ausgeführt werden soll, kann man auch Zählschleifen
verwenden: Mit
for(int i=0;i<7;i=i+1){
huepf();
}
huepf() sieben mal wiederholt.
wird
Hierbei wird die Variable i nur für Zählschleife deklariert und steht danach nicht mehr
zur Verfügung. Im Anweisungsteil der Schleife könnte sie allerdings verwendet werden.
Aufgabe 10:
Schreiben Sie die Methode rechteck(), mit der ein Frosch im Rechteck hüpft: drei
Felder vor, vier Felder hoch,…
Gehen sie wieder zur Vereinfachung davon aus, dass kein Hindernis im Weg ist.
Tipp: Mit einem zusätzlichen Objekt der Klasse Greenfoot, das in dieser Methode
erzeugt wird, kann man die Zeit verzögern, so dass man den Frosch hüpfen sieht:
Greenfoot gf=new Greenfoot();
…
gf.delay(20);
2.2.5
Methoden mit Parameter
Variablen sind auch hilfreich, wenn Methoden mit verschiedenen Werten ausgeführbar
sein sollen.
Beispielsweise gibt es in der Klasse Frosch eine Methode void setzeRichtung(int
wohin). Wenn man sie (via rechten Mausklick auf den entsprechenden Frosch) ausführen
möchte, erscheint ein Fenster, in dem ein Wert für wohin (0 für Ost, 1 für Nord, 2 für
West und 3 für Süd) eingegeben werden soll.
24.08.2015
9
Entsprechend muss auch bei einem Methodenaufruf dieser Methode innerhalb einer
Methode in den runden Klammern ein Wert oder einer Variable, die mit dem Wert
belegt ist, angegeben werden. (Z.B. setzeRichtung(richtung+1);).
Ein anderes Beispiel ist die Methode removeObject(Actor object) der Klasse World.
Wenn man sie nutzt, muss in der runden Klammer der Name des Actors angegeben
werden, der beseitigt werden soll.
Wenn man eine Methode mit Parameter aufruft, wird in der runden Klammer nur der
Wert angegeben bzw. eine Variable, die diesen Wert hat. (z.B. in einer Methode der
Klasse FroschWelt: remove(froschFridolin); )
Wird dagegen eine Methode mit Parameter (neu) implementiert, so muss zusätzlich der
Typ des Parametrs (z.B. int oder Actor) angegeben werden. (z.B. void
setzeRichtung(int wohin){…}.)
Aufgabe 11:
Schreiben Sie eine Methode, mit der ein Frosch x Schritte vorwärts laufen kann, falls
keine Wand im Weg ist und testen Sie sie durch einen geeigneten Aufruf in der Methode
act(). (Falls eine Wand im Weg ist, also der Frosch aus der Welt laufen würde, soll er
nur so viele Schritte wie möglich machen.)
2.3 Verwendung von Methoden der Klasse Greenfoot um
Benutzerinteraktionen zu ermöglichen
Oft sind Reaktionen auf Benutzereingaben erwünscht, zum Beispiel, dass alle Fliegen nach
rechts fliegen, solange der Benutzer/die Benutzerin die Pfeiltaste nach rechts drückt. Hierfür
stellt die Klasse Greenfoot Methoden zur Verfügung.
Um die Methoden verwenden zu können, wurde in der Klasse Fliege des Szenarios
FliegeFliegen1 ein Objekt der Klasse Greenfoot deklariert und im Konstruktor (der Klasse
Fliege) erzeugt, um es anschließend in der Methode act() (der Klasse Fliege) zu
verwenden:
public class Fliege extends Actor
{private int richtung; //ost=0,nord=1,west=2,süd=3
private Greenfoot gf;
public Fliege(){
setzeRichtung(0);
gf=new Greenfoot();
}
24.08.2015
10
public void act(){
if(gf.isKeyDown("left")){
setzeRichtung(2);
flieg();
}
else if (gf.isKeyDown("right")){
setzeRichtung(0);
flieg();
}
else if (gf.isKeyDown("down")){
setzeRichtung(3);
flieg();
}
else if (gf.isKeyDown("up")){
setzeRichtung(1);
flieg();
}
}
...
}
Da es sich bei der Methode isKeyDown (String keyname) der Klasse Greenfoot um eine
statische Methode handelt (was man am Schlüsselwort static erkennt), ist es auch möglich
die Methode direkt z.B. mit Greenfoot.isKeyDown(„up“); als Klassenmethode aufzurufen,
ohne ein Objekt dieser Klasse zu erzeugen. (s. Szenario FliegeFliegen2).
Aufgabe 12:
Öffnen Sie das Szenario „FroschVorlageAufgabe12“. Hier läuft ein Frosch in der untersten
Zeile hin und her. Ändern Sie seine Methode huepfHinUndHer() so ab, dass er nach oben
springt, wenn die „j“-Taste (für „jump“)gedrückt ist, andernfalls wieder auf den Boden fällt
bzw. falls er noch oder schon wieder am Boden ist, weiter hin und her hüpft.
Tipps: Bei mittlerer Geschwindigkeit funktioniert das Szenario am Besten. Verwenden Sie
Bedingungen, keine Schleifen. (Die Wiederholungen entstehen durch die wiederholte
Ausführung der Methode, dadurch, dass sie in der Methode act() aufgerufen wird.)
3 Eigene Szenarien erstellen
1.) Neues Szenario anlegen
Ein neues Szenario legt sich fast von selbst an:
Im Hauptmenü auf „Scenario“ „New… „ klicken, dann einen neuen Szenarionamen
eingeben und auf „Create“ klicken.
24.08.2015
11
Schon ist ein neues Szenario entstanden.
2.) Neue Welt implementieren
Mit der rechten Maustaste kann man rechts auf die Klasse World klicken und einen neue
Unterklasse anlegen. Sie muss einen Namen bekommen, der in dem Textfeld, in dem
fenster, das erscheint, einzutragen ist. Außerdem kann man in diesem Fenster einen
Hintergrund auswählen. Der Hintergrund kann stattdessen oder zusätzlich auch mit
Grafikmethoden der Klasse GreenfootImage erstellt werden, z.B.:
GreenfootImage bg=getBackground();
bg.setColor(Color.BLUE);
bg.fill();
bg.setColor(Color.BLACK);
for (int i=0; i<10; i++)
{bg.drawLine(i*60,0,i*60,10*60);
bg.drawLine(0,i*60,10*60, i*60);
}
Die Größe der einzelnen Felder und der gesamten Welt lässt sich durch den Aufruf des
Konstruktors der Oberklasse World festlegen: super(10, 10, 60);
Hier wird ein Feld mit 10 mal 10 Feldern der Größe 60x60 Pixel angelegt.
3.) Aktoren implementieren
Dies wurde schon in II beschrieben. Wenn ein selbst erstelltes Bild verwendet werden
soll, speichert man die entsprechende jpg- oder gif-Datei im Unterordner image des
Szenario-Ordners im Ordner Szenarien oder klickt in dem Fenster, das zur Erstellung
einer Unterklasse erscheint „Browse for more images“. Nachträglich kann man das
Aussehen mit der Methode setImage(…) ändern.
Hierbei ist genau zu überlegen, welche Unterklassen der Klasse Actor benötigt werden.
Insbesondere wird bei einem Klick auf „Act“ die Methode act() jedes Objekts in der
Welt ausgeführt. Wenn einige Objekte auf diesen Klick in irgendeiner Art und Weise
agieren sollen und andere nicht oder anders, sind zwei verschiedene Klassen notwendig,
die sich (u.a.) in der Methode act() unterscheiden.
Aufgabe 13:
Erstellen Sie ein neues Szenario „boats“ (s. Abbildung). Nutzen Sie dafür die Verfügung
stehenden Bilddateien „shoe.jpg“ und „boat.jpg“, sowie das Bild „lighthouse“ der GreenfootGallery.
24.08.2015
12
Ein mögliches Implementationsdiagramm für diese Szenario ist:
W o rld
Sea
ra n d o m ize r: R a n d o m
S e a (...)
p o p u la te (...)
ra n d o m S h o e s (...)
A c to r
L ig h tH o u s e
a c t(...)
S a ilin g B o a t
E A S T : in t
W E S T : in t
N O R T H : in t
S O U T H : in t
d ire c tio n : in t
s h o e s F is h e d : in t
S ho e
a c t(...)
S a ilin g B o a t(...)
a c t(...)
fo u n d S h o e (...)
fis h S h o e (...)
m o v e (...)
c a n M o v e (...)
tu rn R a n d o m (...)
tu rn L e ft(...)
s e tD ire c tio n (...)
g e tS h o e s F is h e d (...)
24.08.2015
13
Quellen:
http://www.greenfoot.org/ abgerufen am 21.08.2015
Greenfoot Szenarien: http://www.greenfoot.org/scenarios/ und http://greenfootgallery.org/,
jeweils abgerufen am 21.08.2015
Greenfoot Tutorials: http://www.greenfoot.org/doc, abgerufen am 21.08.2015
Mathias Müller, Ralf Punkenburg bzw. Jürgen Frank (redaktionell): Anfangsuntericht mit
Greenfoot, Landesinstitut für Schule und Medien Berlin-Brandenburg (LISUM),
Ludwigsfelde-Struveshof, 2007:
http://bildungsserver.berlin-brandenburg.de/inf_greenfoot1.html, abgerufen am 21.08.2015
Michael Kölling: Introduction to Programming with Grennfoot, Pearson-Verlag, New Jersey
2010
Michael Kölling: Einführung in Java mit Greenfoot: Spielerische Programmierung mit Java,
Pearson-Verlag, Juni 2010
Kempe, Löhr, Tepaße:Informatik - Lehrwerk für die gymnasiale Oberstufe - Neubearbeitung:
Schülerband 1: Einführungsphase, Schöningh-Verlag 2014
24.08.2015
14

Download Report