Objektorientierter Einstieg mit NIKI, dem JAVA-Roboter
(passend zum neuen Rahmenplan Informatik in Berlin)Version 0.9, 02.05.2004
kokavecz@humboldt.be.schule.de
Auf dieser Seite finden Sie:
|
Ursprünge und Versionen der "Murmeltiere":
Schon 1981 stellte Richard Pattis "Karel the Robot" vor. Innerhalb weniger Jahre erschienen
mehrere Veröffentlichungen, die die Ideen von Pattis aufgriffen und Anregungen für einen interessanten
algorithmenorientierten Einstieg in den Informatikiunterricht geben wollten (z.B. Murmeltierwelt
und Pascal von H. Pinke (1987), Niki in INFORMATIK EINS von Hermes und Stobbe (1990)). Bei diesem Einstieg
stehen die Algorithmen und die Methode der schrittweisen Verfeinerung im Vordergrund. Man
nennt diesen Einstieg oft auch "variablenfrei", weil das Thema "einfache Variablen und ihre Datentypen"
zunächst außen vor bleiben kann. 1989 habe ich für unsere NCR-Unix-Anlage, die an
Berliner Schulen weit verbreitet war, eine Niki-Version für Standardpascal
programmiert und in Lehrerfortbildungsveranstaltungen vorgestellt und weitergegeben, kurz darauf
habe ich Niki nach Turbo-Pascal und mcs-Modula portiert. Vor wenigen Jahren folgte dann die erste
objektorientierte Version (NIKO) für Python (seit 2000 auf meiner Homepage).
Warum nicht Kara ? (gemeint ist die Java-Version der ETH-Zürich): Für Schulen, die Java als Programmiersprache einsetzen, gibt es seit langem KARA. Kara folgt dem traditionellen Ansatz und erlaubt es, algorithmenorientiert unterschiedliche Aufgaben zu lösen. Dabei steht eine sehr hübsche und komfortable graphische Arbeitsumgebung zur Verfügung. Objektorientierte Ansätze wie Vererbung oder Objekterzeugung fehlen aber, obwohl Kara in Java geschrieben ist. Wenn man sich an einer Schule für Java und "Objektorientierung von Anfang an" entscheidet, passt dieses Kara nicht mehr in das Unterrichtskonzept. |
|
"Objektorientierung" bei Robotern und was man nebenbei noch lernen kann: Natürlich behält die algorithmische Arbeit bei der Lösung typischer Murmeltier-, Roboter- oder Käferaufgaben ihren exponierten Platz, schließlich gehören Algorithmen zu den fundamentalen Ideen der Informatik. Wie bisher werden Schüler programmiersprachenfrei Algorithem und Unteralgorithmen entwerfen und darstellen. Anders als bei den bisherigen Robotersystemen finden sich die Unteralgorithmen aber bei meinen "objektorientierten Robotern" für Java und Python in den Methoden neu zu programmierender Roboterklassen wieder. Diese von den Schülern zu entwickelnden Robotermodelle beerben dabei (u.U. über mehrere Generationen) eine sehr primitive Roboterklasse (niki), die nur die öffentlichen Methoden nimm, gib, vor, links, vorneFrei und feldLeer kennt.
Mit diesem Ansatz kann man von Anfang an beim Problemlösungsentwurf objektorientiert vorgehen und gelangt dabei deutlich über die reine "Punkt-Notierung" hinaus. Der Ansatz erlaubt es zudem, beliebig viele Roboter - ggf. auch mit unterschiedlichen Eigenschaften - zu erzeugen und gemeinsam oder auch konkurrierend in einer vorgegebenen Welt arbeiten zu lassen (threads).
|
Auch NIKI, der objektorientierte Java-Roboter, kommt (wie mein NIKO für Python) mit einer graphischen
Oberfläche daher. Sie kann
- ohne in den Quelltext eingreifen zu müssen - in gewissen Grenzen eigenen Vorstellungen angepasst werden, wie nebenstehende Abbildung zeigt. Allerdings beschränkt sich die Nutzung der graphische Oberfläche
auf den Ablauf des Programms, mit dem Niki gesteuert oder eine neue Welt generiert wird.
Meiner Beobachtung nach haben zu Beginn des Unterrichts selbst interessierte Informatikschüler heute kaum noch Vorstellungen von der Struktur oder gar Arbeitsweise der von ihnen benutzten Hardware- und Softwarekomponenten. Kaum jemand kennt den Unterschied zwischen ausführbaren Programmen und einfachen Dateien, fast niemand weiß etwas über die Organisation eines Dateisystems oder gar über Zugriffsrechte. Die bunte Welt der integrierten Werkzeuge und graphischen Oberflächlichkeit lässt Erstaunen aufkommen, wenn ein Programmtext mit unterschiedlichen Editoren "kompatibel" bearbeitet werden kann und dann von einem Programmiersprachenprozessor - möglicherweise sogar noch auf einem anderen Rechnersystem - "verstanden" wird oder wenn durchgeführte Arbeiten "lesbar" auf dem Rechner in Dateien (Textdateien) wiedergefunden werden. |
Aus diesem Grund wird bei meinem System auf integrierte Editoren oder Hilfen zur Übersetzung und zum Start der Programme verzichtet (back to the roots). Die Schüler benutzen einen beliebigen Editor, rufen auf der Kommandoebene den Compiler und die virtuelle Maschine auf, um die von ihnen bearbeiteten Programme ausführen zu lassen und beobachten die am Programmenstehungsprozess beteiligten Dateien (Transparenzprinzip). Gibt der Lehrer eine Weltdatei für die Bearbeitung einer Aufgabe vor, so lernen die Schüler, dass sie diese nicht verändern können (Zugriffsrechte), es sei denn, man erzeugt eine Kopie im Heimatverzeichnis. Gleichzeitig lernen Sie die Verzeichnisstruktur auf der verwendeten Rechneranlage kennen.
Soll eine vorhandene Welt bearbeitet werden, so ist der entsprechende Dateiname (mit oder ohne Extension) als Parameter anzugeben:
nikied meineErsteWelt
also: nikied [weltname]
Im vorliegenden Beispiel ergänzt nikied den Dateinamen zu "meineErsteWelt.welt". Mit der Maus können nun in der 17x14 Einheiten großen Welt Mauern gesetzt werden. Soll eine Mauer entfernt werden, so reicht ein erneutes Ankllicken des Feldes. Sollen Werkzeuge (Hammer und Nagel) verteilt werden, so ist zuvor auf die Taste "tools+" zu drücken. Es können mehrere Werkzeuge auf einem Feld liegen! Nach Drücken von "tools-" können Werkzeuge auch wieder entfernt werden. Mit "store world" wird die gerade bearbeitete Welt in der am Anfang angegebenen Datei gespeichert. Wurde nikied ohne Angabe einer Weltdatei gestartet, so verwendet nikied den Dateinamen "unbekannte.welt"
Das Programm nikiti (Teach In) wird bei geeigneter Einrichtung (s.unten) mit
nikiti
nikiti meineErsteWelt
oder mit
nikiti meineErsteWelt meinErstesProgramm.java
aufgerufen.
also: nikiti [weltname [programmname]]
Dieses Programm erlaubt es mit Hilfe der Maus den Roboter in seiner Welt über entsprechende Tasten manuell zu steuern. Beim Verlassen des Programms findet man in der optional anzugebenden Programmdatei (oder ohne entsprechende Angabe in "meinProgramm.java") ein syntaktisch einwandfreies Java-Programm, das die zuvor manuell gesteuerte Roboterbewegung beliebig oft zu wiederholen gestattet. Der beim Programmlauf entstandene Quelltext (hier ein Beispiel) muss natürlich mit javac übersetzt und mit der virtuellen Maschine (java) ausgeführt werden. Er kann aber auch zuvor noch mit Hilfe eines Editors verändert werden (erste Programmierschritte).
import niki.Welt;
import niki.Niki;
public class meinProgramm{
public static void main(String[] args){
Welt meineWelt = new Welt("unbekannte.welt");
Niki meinRoboter = new Niki(meineWelt);
meinRoboter.vor();
meinRoboter.vor();
meinRoboter.vor();
meinRoboter.vor();
meinRoboter.vor();
meinRoboter.vor();
meinRoboter.links();
meinRoboter.links();
meinRoboter.links();
meinRoboter.vor();
meinRoboter.vor();
}
}
Zum Niki-System gehört das Java-Package "niki", aus dem die Klassen Welt und Niki importiert werden. Bei der Erzeugung des Objekts "meineWelt" (genauer: bei der Ausführung des zugehörigen Konstruktors) wird auf dem Bildschirm das GUI geöffnet. Mit der Erzeugung des Objekts "meinRoboter" erscheint der Roboter links oben in der Welt. Der Roboter muss die Welt "kennen" und erhält deshalb als Parameter die Objektreferenz "meineWelt".
Die Methoden von Niki sind:
void gib()
void nimm()
void vor()
void links()
boolean vorneFrei()
boolean feldLeer()
Nikiti kann von den Schülern auch dazu verwendet werden, sich ein Programmgerüst zu erstellen (man ruft nikied nur einmal auf und verzichtet dann auf die manuelle Steuerung).
Hier ein paar einfache und aufeinander aufbauende
Laden Sie hier bitte jetzt die unterrichtstaugliche Version 0.9 vom 27.04.2004:
Das Niki-System wird weiterentwickelt.
java -jar nikied.jar [parameter1]
java -jar nikiti.jar [parameter1 [parameter2]]
Die Bedeutung der Parameter wurde schon weiter oben beschrieben. Es werden hier der Name der Weltdatei und ggf. noch der Name der Programmdatei angegeben. Wenn der Systemverwalter die jar-Dateien für alle lesbar irgendwo auf dem Server abgelegt hat, so muss entsprechend der gesamte zugehörige Pfad für nikied.jar bzw. nikiti.jar angegeben werden.
Angenommen, man hat ein Programm mit dem Namen meinProgramm.java erstellt, so muss es mit
javac -classpath .:niki.jar meinProgramm.java
in den Java-Pseudocode übersetzt werden (auch hier muss ggf. zu niki.jar der entsprechende Pfad mit angegeben werden). Zur Ausführung des Programms wird die virtuelle java-Maschine benutzt:
java -classpath .:niki.jar meinProgramm
Könner installieren vier Scriptdateien (Ausführungsrechte setzen!) in einem Verzeichnis, das im PATH-Eintrag der Datei /etc/profile steht. Hier die Beispielscripts:
script nikied:
==============
java -jar /usr2/public/jar/nikied.jar $1
script nikiti:
==============
java -jar /usr2/public/jar/nikiti.jar $1 $2
script njavac:
==============
javac -classpath .:/usr2/public/jar/niki.jar $1
script njava:
=============
java -classpath .:/usr2/public/jar/niki.jar $1
Mit diesen Scripts im System können die Schüler dann direkt folgende Befehle verwenden:
nikied meineWelt nikiti meineWelt meinProgramm njavac meinProgramm.java (es entsteht meinProgramm.class) njava meinProgramm (das eigene Programm wird ausgeführt)
java -jar nikied.jar [parameter1]
java -jar nikiti.jar [parameter1 [parameter2]]
Die Bedeutung der Parameter wurde schon weiter oben beschrieben. Es werden hier der Name der Weltdatei und ggf. noch der Name der Programmdatei angegeben. Wenn der Systemverwalter die jar-Dateien für alle lesbar irgendwo auf dem Server abgelegt hat, so muss entsprechend der gesamte zugehörige Pfad für nikied.jar bzw. nikiti.jar angegeben werden.
Angenommen, man hat ein Programm mit dem Namen meinProgramm.java erstellt, so muss es mit
javac -classpath .;niki.jar meinProgramm.java
in den Java-Pseudocode übersetzt werden (auch hier muss ggf. zu niki.jar und zu javac der entsprechende Pfad mit angegeben werden). Zur Ausführung des Programms wird die virtuelle java-Maschine benutzt:
java -classpath .;niki.jar meinProgramm
Könner installieren vier Batchdateien in einem Verzeichnis, das in der Umgebungsvariablen PATH steht. Hier meine Beispielbatchdateien:
batchdatei nikied.bat:
======================
java -jar C:\usr2\public\jar\nikied.jar %1
batchdatei nikiti.bat:
======================
java -jar C:\usr2\public\jar\nikiti.jar %1 %2
batchdatei njavac.bat:
======================
C:\jdk1.3\bin\javac -classpath .;C:\usr2\public\jar\niki.jar %1
batchdatei njava.bat:
=====================
java -classpath .;C:\usr2\public\jar\niki.jar %1
Mit diesen Batchdateien im System können die Schüler dann direkt folgende Befehle verwenden:
nikied meineWelt nikiti meineWelt meinProgramm njavac meinProgramm.java (es entsteht meinProgramm.class) njava meinProgramm (das eigene Programm wird ausgeführt)
CLASSPATH = .:/usr2/public/java/nikipath
export CLASSPATH
Im Verzeichnis /usr2/public/java/nikipath werden dann die drei jar-Dateien ausgepackt:
jar -xvf nikied.jar jar -xvf nikiti.jar jar -xvf niki.jar
Jetzt haben Sie u.a. Zugriff auf die Verzeichnisse nikibilder und können die Welt optisch umgestalten. Sie können nun auch überall ohne die jar-Dateien arbeiten:
java nikied
java nikiti
javac meinProgramm.java
java meinProgramm
Hier werden in Kürze noch Klassendiagramme veröffentlicht, mit deren Hilfe Sie das Niki-System selber verändern und weiterprogrammieren können, ohne über den Quelltext verfügen zu müssen.
Version 0.9, 02.05.2004