Unterrichtsentwurf für die Unterrichtsstunde
Schleifenkonstrukte
Fach: Informatik
Schule: Gymnasiale Oberstufe
Straße A
Ort
Klasse: 11.
Unterrichtszeit und –ort: 800 bis 845, Rechner – Raum
Ausgearbeitet von: Dominique Haas
Matrikelnummer:
Dieser Unterrichtsentwurf ist Teil der Studienarbeit „Stoffverarbeitungsplan“ für das Hauptseminar Fachdidaktik der HU – Berlin. Dieser Unterricht findet in der 4. Unterrichtseinheit: „Einführung in die imperative Programmierung“ als vorletzten Unterrichtsstunde dieser Einheit statt.
Folgende Vorraussetzungen wurden vom Seminarleiter vorgegeben:
Informatik-Unterricht in der Sek. II im der 3-jährigen Kursfolge; 3 X 45 Min./Woche. Der "Programmierunterricht" beginnt in der 11. Klasse. Die Schüler haben bis auf wenige Ausnahmen am ITG-Unterricht teilgenommen. Es sind knapp 50% Mädchen im Kurs. Programmiererfahrungen sind vereinzelt und unsystematisch vorhanden. Die Mehrzahl der Schüler verfügt über einen heimischen PC mit Internetzugang.
Die Klassenräume stellen jedem Schüler einen vernetzten Arbeitsplatz sind zur Verfügung. Es sind folgende Compiler vorhanden: Turbo-Pascal 7, Delphi 6, Java mit grafischer Oberfläche, Python. Die Fachkonferenz hat C++ als schuluntauglich ausgeschlossen.
Der Unterrichtsraum verfügt abgesehen von einem vernetzten Rechnerpool über einen Beamer.
Da dieser Unterricht in der vorletzten Unterrichtsstunde der Unterrichtseinheit: „Einführung in die imperative Programmierung“ stattfindet, verfügen die Schüler in dem Gebiet der OOP über folgende Themen Kenntnisse (siehe Stoffverteilungsplan):
Ø Klassen und Objekten
Ø Datentypen und Methoden
Ø Variablenkonzepte
Ø Operatoren
Ø Zuweisungen und Anweisungen
Schleifen gehören zur Erweiterung der Kernsprache. Sie dienen einer besseren Strukturierung des Quellcodes und vereinfachen das Programmieren. Sie legen die wiederholte Ausführung von Anweisungen fest. Eine Schleife besteht aus einer Schleifenbedingung und einem Schleifenrumpf. Man unterscheidet zwei Arten von Schleifen, abweisende Schleifen und nichtabweisende Schleifen.
<while-statement> := while ( <expression> ) <statement>
i = 1;
while (i < 5) {
System.out.println(„Die “ + i „. Ausgabe“);
i++;
}
Die while – Schleife führt solange den Schleifenrumpf aus wie die Bedingung wahr (true) ist. Wenn die Bedingung beim Eintreten nicht erfüllt werden kann, wird der Schleifenrumpf nicht bearbeitet und übersprungen.
<do-statement> ::= do <statement> while ( <expression> ) ;
i = 1;
do {
System.out.println(„Die “ + i „. Ausgabe“);
i++;
} while (i < 5);
<expression> ::= <assignment-expression>
<for-init> ::= {<statement-expression>}*(,)
| <local-variable-declaration>
<for-update> ::= {<statement-expression>}*(,)
<for-statement> ::= for ( {<for-init>}? ; {<expression>}? ; {<for-update>}? ) <statement>
for (i = 1; i < 5; i++) {
System.out.println(„Die “ + i „. Ausgabe“);
}
Das Programm Vier – Gewinnt hat im Laufe des Halbjahres verschiedene Stadien. Im ersten Stadium können zwei Spieler gegeneinander spielen. Bei der nächsten Version wird ein Siegeszug erkannt. In der Schlussversion verfügt das Spiel über einen Computer – Gegner mit verschiedenen Strategien.
Als nächstes werden die Entwurfsentscheidungen beschrieben, die zu der vorgeschlagenen Klassenstruktur einer Implementation des kompletten Spiels geführt haben. Die Struktur wird als UML-Klassendiagramm angegeben. Das Diagramm enthält nicht die von den Klassen bereitgestellten Methoden, damit die Übersichtlichkeit gewahrt bleibt.
Zur Implementation des Spiels VierGewinnt gehört die Klasse VierGewinnt, die die Spielregeln implementiert. Weiter gehören zwei Spieler dazu. Außerdem ist der Spielstand zu merken. Soweit ist die Struktur durch das Problem vorgegeben.
Wichtigste Entwurfsentscheidung ist die Trennung von Spielstand und der graphischen Repäsentation des Spielstandes, das Spielfeld. Das entspricht der Möglichkeit, im Spielwarenladen sehr unterschiedliche VierGewinnt-Spiele zu kaufen, die aber alle geeignet sind, den Spielstand zu zeigen. Das Spielfeld ist daher (ebenso wie die beiden Spieler) Parameter von VierGewinnt.
In gleicher Weise wurden Spieler und der SpielerDialog, die graphische Darstellung eines Spielers, voneinander getrennt. Ein Spieler kann durch eine auf dem Computer implementierte Strategie ( ComputerSpieler ) oder den Nutzer des Programms, also einen Menschen (MenschSpieler ) gegeben sein. Beide Klassen von Spielern führen einen unterschiedlichen Dialog. Der Mensch muss eine Spalte auswählen (MenschDialog). Bei einem ComputerSpieler ist zu sagen, wann er ziehen soll, also seinen Zug berechnen und dann ausführen soll (ComputerDialog). Das ist notwendig, damit auch zwei "Computerspieler", also zwei unterschiedliche Spielstrategien, gegeneinander spielen können. In diesem Fall will man sich jeden Zug ansehen, bevor man den nächsten Zug veranlasst.
Aus dem Paket java.awt stammen die Klassen Frame und Panel. VierGewinnt ist ein Frame, in das die als Panel implementierten SpielerDialoge und das Spielfeld eingefügt werden.
Bei diesem Unterrichtsthema eignet sich eine problemorientierte Unterrichtsmethode.
Man kann zwar bei der Programmierung auf Schleifen verzichten, doch führt dieses zu einem aufgeblähten, unlesbaren Quellcode. Ein solcher Quellcode kann industriell nicht gepflegt, gewartet oder portiert werden. Er findet also in der Praxis ausgenommen Spezialfälle (unter Umständen bei der Programmierung von RISC) keine Anwendung.
Die Verwendung von Schleifen ist aus den oben genannten Gründen also unumgänglich. Schaltungssynthese ist für einen handlungsorientierten Unterricht bei vielen Praxisaufgaben im Labor unumgänglich.
Ich entschied mich für folgende Grundstruktur:
· Phase1: Problemorientierten Einstieg
· Phase 2: Stofferarbeitung (Einatmen)
· Phase 3: Übung, Stofffestigung(Ausatmen)
· Phase 4: Hausaufgabe, Stofffestigung
Das wichtigste bei einem problemorientierten Einstieg besteht darin, das Problem den Schülern klar darzustellen. Jeder Schüler in der Klasse muss die Problematik vollends erkennen und begreifen. Sonst geht der Effekt verloren und sorgt bei den Schülern für Unaufmerksamkeit und Desorientierung.
Zunächst sind die Schüler gefordert sich über den erforderlichen Ablauf zur Lösung des Problems Gedanken zu machen. Dabei wird erreicht, dass die Schüler Ihre bisher gesammelten Erfahrungen aktivieren und Miteinbringen. Durch die Aufforderung Ihre Ergebnisse an die Tafel zu schreiben, wird eine zusätzlich körperliche Schüleraktivität zum Anfang der Stunde erreicht. Dadurch erhoffe ich eine gewisse Spannung und somit auch eine gewisse Aufmerksamkeit für die gesamte Unterrichtseinheit zu erhalten.
In einem Lehrer-Schüler-Gespräch und mit Hilfe der Java Dokumentation werden die einzelnen Schleifen abgearbeitet. Da dieser neue Unterrichtsinhalt gemeinsam erschlossen werden soll, eignet sich besonders der Beamer oder die Tafel als Medien Einsatz.
Hier findet die eigentliche Lernphase statt, in der die Schüler anhand eines neuen Beispiels selbstständig einen Schleifenalgorithmus entwickeln. Als Übungsaufgabe soll das automatische Erkennen eines Gewinnerzuges dienen. Für eine bessere Visualisierung des Problems wird das Brettspiel zur Erläuterung des Problems benutzt. Um eventuell einzelne Schüler nicht zu überfordern, erfolgt die Umsetzung der Aufgabe in zwei Schritten. Bei dem ersten Schritt wird in einem Lehrer – Schüler Gespräch der Algorithmus zur Erkennung von 4 vertikalen Spielsteine eines Spielers entwickelt. Anschließend erfolgt die Umsetzung des gefundenen Algorithmus in Java von den Schülern und wird von einem Schüler präsentiert. Der nächste didaktische Schritt ist die selbstständige komplette Entwicklung des Algorithmus zur Erkennung von 4 gleichen wagerechten Spielsteinen.
Als Hausaufgabe sollen die Schüler das automatische Erkennen von diagonalen Gewinnzügen implementieren. Die Hausaufgabe dient abgesehen von der Festigung des neu erlernten Stoffes auch zur Vervollständigung des Programms Vier – Gewinnt. Denn wenn später ein Computer Spieler implementiert werden soll, werden diese Methoden benötigt.
Die Schüler sollen in der Lage sein für ein entsprechendes Problem eine entsprechende Schleife zu entwickeln (K5).
LZ1: (K1) Die Schüler sind in der Lage die 3 Java - Schleifen zu nennen.
LZ2: (K1) Die Schüler können die Syntax der Schleifen aufschreiben.
LZ3: (K4) Die Schüler können über eine Aufgabenstellung das gestellte Problem analysieren und einen entsprechenden Schleifenalgorithmus entwickeln.
Zeit / Phase |
LZ |
Unterrichtsorganisation |
AuS |
Medien |
Didaktische Funktion |
||||
8:00 Uhr 3 min 8:03 Uhr |
|
Anwesenheitskontrolle L. informiert über den Ablauf der Stunde |
LV |
Audio |
Information |
||||
Phase 1: Problemorientierter Einstieg: Es soll zur Laufzeit eines Programms bestimmt werden wie oft eine Ausgabe (System.out) ausgegeben werden soll. Vervollständigen Sie die gegebene Methode. |
|||||||||
I8:03 Uhr 5 min 8:08 Uhr |
|
L. stellt die Frage und stellt die zu vervollständigen Methode vor. S. stellen Ihre Vorschläge vor. |
LSG
|
Audio Beamer
|
Motivation,
|
||||
Phase 2: Stofferarbeitung (Einatmen) |
|||||||||
II8:08 Uhr 20 min 8:28 Uhr |
L1 |
L. + S. erarbeiten anhand der Syntax – Dokumentes die Funktionsweise der Schleifen und sichern die Erkenntnisse schriftlich. |
LV |
Beamer |
Stofferarbeitung |
||||
Phase 3: Übungsaufgabe (Ausatmen): Das Spiel Vier Gewinnt soll selbstständig den Gewinner erkennen. |
|||||||||
III 8:28 Uhr 15 min 8:43 Uhr |
L1 L2 L3 |
L. erläutert die Methoden um das das Spiel Vier – Gewinnt ergänzt werden soll. L. + S. erarbeiten sich den nötigen Algorithmus. S. vervollständigen die Methoden zu Erkennung von vertikale und horizontale Sequenzen. |
LV
LSG
SG
|
PC Beamer Brettspiel |
Festigung des neu erlernten Stoffes |
||||
Phase 4: Festigung Hausaufgabe |
|||||||||
IV 8:43 Uhr 2 min 8:45 Uhr |
L3 |
S. sollen als Hausaufgabe die Methode zur Erkennung der diagonalen vervollständigen. |
SE |
Diskette Beamer |
Sicherung, Soziale Kompetenz |
||||
|
AB – Arbeitsblatt |
LSG - Lehrer-Schüler-Gespräch |
SG – Schülergruppen |
|
|||||
|
AM – Arbeitsmaterialien |
LV – Lehrervortrag |
SSG - Schüler-Schüler-Gespräch |
|
|||||
|
AuS - Aktions- und Sozialform |
PA – Partnerarbeit |
RS – Rollenspiel |
|
|||||
|
GA – Gruppenarbeit |
TB – Tafelbild |
WD – Worddokument |
|
|||||
|
L – Lehrer |
S – Schüler |
|
|
|||||
|
LI – Lehrer Information |
SE – Schüler Eigentätigkeit |
|
|
|||||
Die Schüler erhalten dieses Dokument nicht vollständig (roter Text auf dem Ausdruck nicht vorhanden) ausgedruckt. Sie haben aber auch die Möglichkeit den fehlenden Text selber direkt in das Dokument einzutippen. Der Lehrer tippt den roten Text auch erst im Unterricht. Das grüne gilt der Orientierung für welche Phase das Arbeitsblatt verwendet werden soll.
Der Quellcode in der Version der zu diesem Zeitpunkt den Schüler zur Verfügung steht ist dem Anhang zu entnehmen.
Unterrichtsthema Schleifen
a)
Vervollständigen Sie die Methode Out( )
in der folgende Ausgabe mittels System.out.println( ..) auf dem Monitor
erscheint:
Das ist die 1. Ausgabe.
Das ist die 2. Ausgabe.
Das ist die 3. Ausgabe.
b) Was wäre, wenn Sie nun 1000 Ausgaben ausgeben möchten?
c) Nun wollen Sie zur Laufzeit die Anzahl der Ausgaben vom User bestimmen lassen. Wie implementieren Sie die Methode? (Einlesen über i = Keyboard.readInt();)
Schleifen gehören zur Erweiterung der Kernsprache. Sie dienen einer besseren Strukturierung des Quellcodes und vereinfachen das Programmieren. Sie legen die wiederholte Ausführung von Anweisungen fest. Eine Schleife besteht aus einer Schleifenbedingung und einem Schleifenrumpf. Man unterscheidet zwei Arten von Schleifen, abweisende Schleifen und nichtabweisende Schleifen.
Man unterscheidet zwei Arten von Schleifen, abweisende Schleifen und nichtabweisende Schleifen.
<while-statement> := while ( <expression> ) <statement>
i = 1;
while (i < 4) {
System.out.println(„Die “ + i „. Ausgabe“);
i++;
}
Die while – Schleife führt solange den Schleifenrumpf aus, wie die Bedingung wahr (true) ist. Wenn die Bedingung beim Eintreten nicht erfüllt werden kann, wird der Schleifenrumpf nicht bearbeitet und übersprungen.
<do-statement> ::= do <statement> while ( <expression> ) ;
i = 1;
do {
System.out.println(„Die “ + i „. Ausgabe“);
i++;
} while (i < 4);
<expression> ::= <assignment-expression>
<for-init> ::= {<statement-expression>}*(,)
| <local-variable-declaration>
<for-update> ::= {<statement-expression>}*(,)
<for-statement> ::= for ( {<for-init>}? ; {<expression>}? ; {<for-update>}? ) <statement>
for (i = 1; i < 5; i++) {
System.out.println(„Die “ + i „. Ausgabe“);
}
Dieser Programmausschnitt zeigt nur eine mögliche Lösung. Man sollte lieber eine etwas einfachere for – Schleife mit Rumpf verwenden. Versuchen Sie die 1. Lösung senkrechteSequenz gemeinsam zu entwickeln.
/** Chips des Spielers untereinander
**/
int senkrechteSequenz(Spieler spieler, int zeile, int spalte){
int i;
int ss = 1; // senkrechte Sequenz
for( i= zeile - 1; // Suche beginnt eine Zeile tiefer
i >= 0 && spielMatrix[i][spalte] == spieler; i--, ss++);
return ss;
}
/** Chips des Spielers nebeneinander
**/
int waagerechteSequenz(Spieler spieler, int zeile, int spalte){
int i;
int ws = 1; // waagerechte Sequenz
for ( i = spalte +1; i<spalten && spielMatrix[zeile][i] == spieler;
i++, ws++);
for ( i = spalte - 1; i>=0 && spielMatrix[zeile][i] == spieler;
i--, ws++);
return ws;
}
Die folgenden beiden Methode zeigen mögliche Lösungen der Hausaufgaben.
/** Chips des Spielers nebeneinander in Diagonale
von lins unten nach rechts oben
**/
int aufwaertsSequenz(Spieler spieler, int zeile, int spalte){
int i;
int j;
int ds = 1; //Diagonale aufwaerts
for ( i = spalte +1, j = zeile +1;
i<spalten && j <spalten && spielMatrix[j][i] == spieler;
i++, j++, ds++
);
for ( i = spalte - 1, j = zeile - 1;
i>=0 && j >=0 && spielMatrix[j][i] == spieler;
i--, j--, ds++
);
return ds;
}
/** Chips des Spielers nebeneinander in Diagonale
von rechts oben nach links unten
**/
int abwaertsSequenz(Spieler spieler, int zeile, int spalte){
int i;
int j;
int ds = 1; //Diagonale abwaerts
for ( i = spalte +1, j = zeile -1;
i<spalten && j >=0 && spielMatrix[j][i] == spieler;
i++, j--, ds++
);
for ( i = spalte - 1, j = zeile + 1;
i>=0 && j < spalten && spielMatrix[j][i] == spieler;
i--, j++, ds++
);
return ds;
}