Grundlagen der Programmentwicklung mit Java und Greenfoot

Inhalt der Lehr- und Lernprozesse:
Grundlagen der Programmentwicklung mit Java und Greenfoot
Thema der Lehr- und Lernprozesse:
Wie weit können sich Wombats vermehren?
Thema der Lehr- und Lernprozesse
Wie weit können sich Wombats vermehren? In der Unterrichtseinheit soll das Greenfoot-Szenario Wombats zu eine Räuber und Beute Beziehung
erweitert werden. Wombats fressen Pflanzen, die natürlichen Feinde sind Dingos. Hat eine Spezies nicht genügend Nahrung, so stirbt sie.
Räuber und Beute Beziehungen sind Inhalt im Biologieunterricht der Oberstufe.
Der fachlich-inhaltliche Schwerpunkt
SACHANALYSE
−
Grundlagen der Programmierung (Variablen, Verzweigung, Schleifen, Zuweisung, Methoden, ...)
−
OOP (Klassen, Objekte, Vererbung, Modellierung, …)
−
Grundlagen von Greenfoot
Die Standards des Rahmenlehrplans
Der Berliner Rahmenlehrplan sieht den Inhalt „Grundlagen der imperativen Programmierung“ vor. Hier soll Algorithmik im kleinen entwickelt werden
und Dokumentationsunterstützende Techniken verwendet werden. Zu letzterem gehören Klassendiagramme, Struktogramme oder
Sequenzdiagramme. Optional kann das Konzept der Objektorientierten Programmierung behandelt werden.
Die von der Lehrkraft angestrebte, längerfristige Kompetenzentwicklung
möglicher Unterrichtsverlauf
Stunde
Konkreter Inhalt
Bemerkung
1
Einführungsstunde
Greenfoot kennen lernen /
Java Befehle erarbeiten (und den
jeweiligen Scratch- Pendant)
- Advance Organizer vorstellen
- Erwartungen an Lernende
- Vorstellen der Lernform
2
Greenfoot kennen lernen /
Java-Befehle / Konzepte /
Dokumentieren
Beraten der Lernenden
3
Java-Befehle / Konzepte /
Dokumentieren
Beraten der Lernenden /
Plenumsphase
4
Java-Befehle / Konzepte /
Dokumentieren
Beraten der Lernenden
5
Java-Befehle / Konzepte /
Dokumentieren
Beraten der Lernenden /
Plenumsphase
6
Java-Befehle / Konzepte /
Dokumentieren
Beraten der Lernenden
7
Java-Befehle / Konzepte /
Algorithmen / Dokumentieren
Beraten der Lernenden
8
Java-Befehle / Konzepte /
Algorithmen / Dokumentieren
Beraten der Lernenden /
Plenumsphase
9
Algorithmen / Dokumentieren
Beraten der Lernenden /
Plenumsphase
10
Algorithmen / Dokumentieren
Beraten der Lernenden
11
Algorithmen / Dokumentieren
Auswertung
Prozessbezogene Kompetenzentwicklung der Lerngruppe:
−
−
−
Informatiksysteme verstehen (erläutern Eigenschaften von Algorithmen an einfachen
Beispielen)
Problemlösen (setzen Algorithmen in Programme um)
Kommunizieren (dokumentieren ihre Arbeitsergebnisse)
Die Begründung der Lehr- und Lernstruktur
Während der gesamten Unterrichtseinheit sollen die Lernenden selbstständig lernen. Da die SuS im späteren Leben viel Neues Lernen müssen und
sie da in der Regel keinen Lehrer haben, sollen sie schon in der Schule auf diese Situation vorbereitet werden. Dies ist ein langfristig angelegter
Prozess, zu dem mit dieser Unterrichtseinheit beigetragen werden soll.
Die SuS erhalten einen Auftrag, zu dessen Erfüllung sie sich selbst Wissen aneignen müssen. Hierzu gehören die Bedienung von Greenfoot und
einige grundlegende Konzepte der Programmiersprache Java. Zudem sollen die SuS Kompetenzen im Bereich Informatiksysteme verstehen
weiterentwickeln. Konkret wird ein Algorithmus zur Simulation von Räuber-Beute-Beziehungen entwickelt und implementiert.
Da die SuS selbstständig arbeiten können, können sie auch ihren eigenen Lernweg steuern. Zur Orientierung erhalten die SuS einen Advance
Organzier und Lernhilfen. Zu den Lernhilfen gehören Arbeitsblätter und Java-Funktionen. Die Arbeitsblätter unterstützen die Aneignung von Wissen
und helfen bei der Strukturierung des Vorgehens. Die bereitgestellten Java-Funktionen haben die Aufgabe der didaktischen Reduktion, da die
Lerngruppe bisher keine Erfahrung beim der Programmentwicklung mit Java besitzt. Die SuS können sich nun auf das Kombinieren der gegebenen
Hilfsfunktionen mit den Kontrollstrukturen von Java konzentrieren. All die Feinheiten, die bei Java zu beachten sind, werden erst im nächsten Lernjahr
thematisiert.
Als Sozialform habe ich die Partnerarbeit gewählt. Die SuS können sich gegenseitig unterstützen und müssen miteinander kommunizieren und
kooperieren. Da sich die SuS einen Partner auswählen können (und sollen), der jeweils auf einem ähnlichen Niveau (Tempo, kognitive Fähigkeiten)
liegt, können die Teams ihr eigenes Lerntempo bestimmen und ihren eigenen Lernweg beschreiten. Die Aktivität der SuS ist bei Partnerarbeit im
Vergleich zu Plenumsphasen hoch. Eine passives Konsumieren des Unterrichts ist so nicht möglich. Die Teams sollen auch lernen, sich realistische
(Teil-)Ziele zu setzen. Ist ein gesetztes Ziel zu hoch, steigt die Frustration. Bei zu niedrigen Zielen, leidet die Motivation, da sich das Erreichen des
Ziels nicht besonders lohnt. [7]
Alle Gedanken und Vorhaben sollen zur Selbstkontrolle / Selbstreflektion in einem Lerntagebuch festgehalten werden.
Da das Erreichen des selbständigen Arbeitens langwierig ist, sind bei Bedarf Plenumsphasen geplant. Diese haben den Zweck, dass Fragen von den
SuS gestellt und beantwortet werden. Eine andere Funktion der Plenumsphasen ist die Sicherung von Erkenntnissen / Ergebnissen, sowie die
Vertiefung und Veranschaulichung von Konzepten.
Quellen
[1] Duden Informatik SI, SII
[2] Michael Kölling – Einführung in Java mit Greenfoot
[3] Rahmenlehrplan Informatik Sek. I und Sek. II, Senatsverwaltung BWF, Berlin 2006
[4] Fachbrief Informatik Nr. 4 Herausgeber: Abteilung Schule - VI Ltr. - , veröffentlicht am:
25.09.2009, DokumentNr: 3754
[5] http://www.greenfoot-center.de/
[6] http://www.stangl-taller.at/ARBEITSBLAETTER/LERNTECHNIK/Lerntagebuch.shtml
[7] Gerhard Roth – Bildung braucht Persönlichkeit
Anhang
Arbeitsmaterialien
−
Advanced Organizer
−
Lerntagebuch (onf)
−
Lernschritt Greenfoot kennen lernen
−
Lernschritt Die ersten Java-Befehle
− Lernschritt Konzepte von Programmiersprachen
−
Lernschritt Algorithmen
−
Lernschritt Dokumentation
−
Hilfestellungen: verwendbare Java-Funktionen
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Datum:
Advance Organizer
Wie weit können sich Wombats vermehren?
Dokumentation
Greenfoot
Java
Grundlagen von Java
Zuweisung, Verzweigung, Schleifen
Konzepte
Variable, Methode, Klasse, Objekt
Simulation
Umfang der Einheit: 11 Unterrichtsstunden
Erste Unterrichtsstunde der Einheit: Donnerstag, 07. April 2011
Letzte Unterrichtsstunde der Einheit: Montag, 16. Mai 2011
Sozialform: Partnerarbeit
VIEL SPAß
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Datum:
Ihr habe jetzt einen Überblick, was Euch bis Mitte Mai erwartet. Um euren Fortschritt zu
dokumentieren, sollt ihr ein Lerntagebuch verwenden. Das Führen von Lerntagebüchern ist eine
bewährte Methode, die eigene Lernpraxis zu dokumentieren, zu erkunden, zu überprüfen und
möglicherweise zu verändern.
Hilfreich bei der Dokumentation sind folgende Fragen:
−
Was habe ich Neues gelernt, was ist mir aufgefallen?
−
in Bezug auf die Inhalte fachlicher und übergreifender Art (meine inhaltliche
Kompetenz)
−
in Bezug auf mich als Person (meine personale und soziale Kompetenz)
−
Woran werde ich inhaltlich noch weiterarbeiten: wann? Wo? Wie?
−
Was möchte ich in den nächsten Tagen einmal anwenden?
−
Was will ich noch nachholen, was noch klären?
Zudem sollt ihr Programmierfehler im Tagebuch festhalten:
−
Was für ein Fehler trat auf?
−
Warum trat der Fehler auf?
−
Wie habe ich den Fehler korrigiert?
Es gibt zwei Möglichkeiten, wo ihr das Lerntagebuch führen könnt, entscheidet selbst:
−
analog in Papierform
− digital in in einem Wiki / Moodle-Kurs
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Lernschritt: Greenfoot kennen lernen
Aufträge:
Ladet Euch erst einmal das GKS-Wombats-Szenario herunter:
http://ralfanske.de/wpf/Java-Einfuehrung-mit-Greenfoot/gks-wombats.zip
Startet nun Greenfoot und öffnet das entsprechende Szenario.
Zur Hilfe könnt Ihr euch die Einführung anschauen (7. bis 13.):
http://www.greenfoot.org/doc/tutorial/German/Wombat_Tutorial_de_v1.0.html#TOC4154
Setze mehrere Wombats auf das Feld. Was passiert beim drücken von „Run“?
Füge zudem Blätter und Steine hinzu. Was stellst Du fest?
Was bewirken die Buttons?
Act:
________________________________________________
Run:
________________________________________________
Reset: ________________________________________________
Compile: ________________________________________________
Datum:
Wahlpflicht Informatik
Grundlagen der Programmentwicklung mit Java und Greenfoot
Lernschritt: Die ersten Java-Befehle
Schaue Dir in der Klasse Wombat den Quellcode an. (Doppelklick auf Wombat im Klassenfenster).
Suche nun Java-Befehle, die den folgenden Scratch-Befehlen entsprechen könnten. Schreibe die Java-Befehle daneben.
Datum:
Wahlpflicht Informatik
Struktogramm
Grundlagen der Programmentwicklung mit Java und Greenfoot
Scratch-Anweisung
Datum:
Java-Anweisung
if (zahl<3){
// Anweisungen
}
if (zahl<3){
// Anweisungen
}
else {
// Anweisungen
}
for (int i = 1; i<= 10; i++) {
// Anweisungen
}
while (zahl < 3){
// Anweisungen
}
Zahl = 10;
void bewegen(){
}
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Datum:
Lernschritt: Konzepte von Programmiersprachen am Beispiel von Java
Mache Dich mit den folgenden Konzepten vertraut:
Variablen
Eine Variable ist ein bestimmter Speicherplatz für beispielsweise eine Zahl. Jede hat eine Variable
einen Typ und einen Namen.
Beispiel:
int zahl = 3;
// Variable vom Datentyp Integer mit dem Wert 3
String verabschiedung = „Auf Wiedersehen“;
Datentyp
byte b;
short i;
int i;
long i;
float x;
double x;
boolean b;
char c;
String s;
Beispiel
b=123;
i=-1234;
i=-1234;
i=-1234L;
x=-123.45F;
x=-123.45; x=1.0E-23;
b=true; b=false;
c='A';
s="Abc"; s=null;
Methoden
Wird eine Folge von Anweisungen mehrfach benötigt, so muss man diese nicht jedes mal
aufschreiben, sondern erstellt daraus eine Methode.
Wird jetzt die Methode aufgerufen, so springt der Computer beim Ausführen in die erste
Programmzeile der Methode und arbeitet dort weiter. Ist die Methode abgearbeitet, so springt der
Computer wieder in das ursprünglich angeführte Programm.
Beispiel für eine Methode:
void bewegen() {
// Anweisungen für das
// Bewegen des Wombats
// dabei: Beachten der Ränder und anderer Hindernisse
}
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Datum:
Lernschritt: Konzepte von Programmiersprachen am Beispiel von Java
Mache Dich mit den folgenden Konzepten vertraut:
Klasse (Objektorientierte Programmierung)
Eine Klasse ist eine Art Bauplan. Er enthält Programmcode. Im Wombats-Szenario gibt es die
Klassen WombatWolrd, Wombat und Leaf.
Eine Klasse hat immer das folgende Gerüst:
public class Wombat
{
//Quellcode der Klasse
//Hier werden Klassenvariablen und Methoden entworfen.
}
Objekte (Objektorientierte Programmierung)
Ein Objekt ist die konkrete Ausprägung einer Klasse. Wenn also eine Klasse ein Bauplan (z.B. für
ein Haus) ist, dann ist ein Objekt ein Haus. Es können von einer Klasse beliebig viele Objekte
erstellt werden. Diese haben alle die gleichen Grundeigenschaften und Verhaltensweisen
(Methoden), jedoch können die Eigenschaften verschiedene Ausprägungen haben.
Beispiel Wombat zeigt in eine Richtung und hat eine gewisse Anzahl von Blättern gegessen.
Wombat A zeigt beispielsweise Richtung Norden und hat 3 Blätter gegessen, Wombat B zeigt in
Richtung Westen und hat 7 Blätter gegessen.
Objekte werden in der Welt angezeigt (linke Seite), Klassen im Klassenfenster (rechte Spalte)
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Lernschritt: Algorithmen
Überlegt Euch, was Ihr alles zum Lösen des Problems benötigt:
−
Voraussetzungen
− Dingos, Wombats, Blätter, ...
−
Bedingungen
− z.B. Dingos / Wombats können verhungern ..
−
Ziele
− Simulation der Nahrungskette
− auch reduziert möglich (Weglassen der Dingos oder der Blätter ist möglich)
− ...
Tipps:
Macht Euch vorher einen Plan, wie ihr vorgehen wollt und schreibt diesen auf!
Verwendet erst einmal Funktionen und implementiert später dessen Inhalt, z.B.
public void vermehren()
{
// Implementierung später...
}
Diese Technik der Programmentwicklung nennt man übrigens Top-Down-Entwurf.
Datum:
Wahlpflicht Informatik Grundlagen der Programmentwicklung mit Java und Greenfoot
Lernschritt: Dokumentation
Dokumentiert Euer Programm:
Techniken zur Dokumentation:
Festhalten des Algorithmus'
als Text oder in Stichpunkten
Struktogramme
Beispiel:
Kommentare in Java
// Zeilenkommentar mit Slash Slash
/*
Blockkommentar mit Slash Stern über mehrere
Zeilen – Beenden des Kommentars mit Stern Slash
*/
Datum:
Java-Funktionen
Folgende Funktionen können in Eure Simulation benutzt werden. Dazu einfach den Quellcode in
Euer Projekt kopieren und modifizieren.
Blatt vermehren (auf eine zufällige Position):
private Random randomizer = new Random();
World myWorld = getWorld();
int x = myWorld.getHeight();
int y = myWorld.getWidth();
Blatt b = new Blatt();
myWorld.addObject(b,Greenfoot.getRandomNumber(x), Greenfoot.getRandomNumber(y));
Wombat oder Dingo sterben lassen(keine Befehle dahinter ausführen!):
public void sterben()
{
getWorld().removeObject(this);
}
Wombat vermehren:
public void vermehren()
{
Wombat w = new Wombat();
getWorld().addObject(w, getX(), getY());
}
Dingo vermehren:
public void vermehren()
{
Dingo d = new Dingo();
getWorld().addObject(d, getX(), getY());
}
Wombat essen:
public void issWombat()
{
Actor wombat = getOneObjectAtOffset(0, 0, Wombat.class);
if(wombat != null)
{
getWorld().removeObject(wombat);
}
}
Musterimplementierung (hier nur die act-Methoden):
Klasse Blatt:
public void act()
{
// beschränkt auf maximal 100 Blätter insgesamt
// zufällig auf das ganze Feld verteilt
wachsen();
alter++;
}
Klasse Dingo:
public void act()
{
if ((alter > MAX_ALTER)||(hunger>MAX_HUNGER))
{
tot=true;
}
if(!tot)
{
if(wombatGefunden())
{
issWombat();
hunger=0;
}
else
{
hunger++;
dreheDichZufaellig();
if(kannGehen())
{
bewegen();
}
}
vermehren();
alter++;
}
else
{
getWorld().removeObject(this);
}
}
//sterben
Klasse Wombat:
public void act()
{
if ((alter > MAX_ALTER)||(hunger>MAX_HUNGER))
{
tot=true;
}
if(!tot)
{
if(blattGefunden())
{
issBlatt();
hunger=0;
}
else
{
hunger++;
dreheDichZufaellig();
if(kannGehen())
{
bewegen();
}
}
vermehren();
alter++;
}
else
{
getWorld().removeObject(this);
//sterben
}
}
Bildschirmfoto der Simulation