Grundlagen

Diese Seite erklärt die ersten Schritte der imperativen Programmierung mit dem Java-Hamster-Modell.

1. Die main-Prozedur

Wenn ein Hamsterprogramm ausgeführt wird, ruft der Rechner die main-Prozedur auf. Eine Prozedur besteht immer aus zwei Teilen:

1. Name (hier main)
2. Rumpf: Dies ist ein Block von Anweisungen, welcher durch geschweifte Klammern { und } eingefasst wird.

2. Kompilieren

Bevor das Hamsterprogramm ausgeführt werden kann, muss es in eine maschinenlesbare Form gebracht werden. Du kannst es dir so vorstellen: Java ist eine Programmuiersprache, die wir Menschen gut verstehen und die sehr ausdrucksstark ist. Der Computer besteht intern aber aus einem großen Schaltkreis (genannt Prozessor), und dieser versteht nur sehr einfache Befehle. Deshalb muss das Programm in eine einfachere Sprache übersetzt werden, auch kompilieren genannt. Im Hamster-Simulator geschieht dies mit Klick auf .

Manchmal schlägt das Kompilieren fehl, weil ein Fehler im Programmtext festgestellt wird. Diesen musst du dann beheben. Z.B. sagt der folgende Syntaxfehler, dass ein Semikolon in Zeile 17 hinter linksUm() fehlt. Das Wort „Syntax“ steht allgemein für „Grammatik“/„Rechtschreibung“.

3. Ausführen

void main()
{
    vor();
    nimm();
    linksUm();
    linksUm();
    vor();
    gib();
}

Nach der Kompilierung kann das Programm ausgeführt werden . Wie bereits beschrieben, beginnt die Ausführung in der main-Prozedur. Der Rumpf der main-Prozedur besteht nun in der Regel aus einer Sequenz von Befehlen, welche hintereinander von oben nach unten abgearbeitet werden. Diese Befehle sind von unterschiedlicher Bauart; am Wichtigsten sind zunächst aber die Grundbefehle vor(); und linksUm(); und nimm(); und gib(); . Das folgende Programm lässt den Hamster also zunächst einen Schritt nach vorne machen, dann ein Korn aufnehmen, anschließend umdrehen (zweimal nach links drehen), wieder einen Schritt nach vorne machen und abschließend ein Korn ablegen.

Ein Befehl kann manchmal zum Absturz des Programms führen. Dies ist z.B. der Fall, wenn der Hamster vor einer Mauer steht und dann mit dem vor();-Befehl in die Mauer „crasht“. In diesem Fall tritt eine sogenannte MauerDaException auf und das Programm ist vorzeitig beendet. Falls das obige Bsp.programm im links­stehenden Territorium ausgeführt würde, wäre dies die Folge:

void main()
{
    vor();
    rechtsUm();
    vor();
    rechtsUm();
}

void rechtsUm()
{
    linksUm();
    linksUm();
    linksUm();
}

4. Prozeduren definieren und aufrufen

Neben der main-Prozedur lassen sich weitere Prozeduren definieren. Eine definierte Prozedur kann als eine Befehlsabfolge verstanden werden, die mit einem Namen versehen wird. In den Zeilen 9 bis 14 wird die Prozedur namens rechtsUm definiert als Sequenz von drei linksUm();-Befehlen.

Von nun an steht der Befehl rechtsUm(); zur Verfügung, was einem einiges an Tipparbeit erspart. Man nennt den Befehl rechtsUm(); auch einen Prozeduraufruf (Zeilen 4 und 6) der Prozedur rechtsUm.

Eine Prozedur, die aufgerufen wird, muss immer auch definiert worden sein. Die Reihenfolge der Definitionen von main und rechtsUm ist dabei egal, die Prozedur rechtsUm hätte auch vor main definiert worden können. Die beiden Prozeduren stehen „gleichberechtigt“ untereinander; wichtig ist nur, dass sie jeweils für sich genommen nicht „auseinandergerissen“ werden und auch nicht ineinander „verschachtelt“ werden.

Wird eine selbst definierte Prozedur aufgerufen (z.B. in Zeile 4), so

1. springt der Rechner nach vorne zur Prozedurdefinition (Zeile 9),...
2. arbeitet den Rumpf ab (Zeile 11 bis 13), und ...
3. springt wieder zurück zur Aufrufstelle, um den nächsten Befehl abzuarbeiten (Zeile 5).

5. Fallunter­scheidungen und Testbefehle

Häufig kommt es vor, dass der Hamster auf seine Umwelt reagieren soll. Z.B.: „Nimm zunächst ein Korn. Falls die nächste Kachel frei ist, gehe nach vorne. Falls nicht, gehe nach links. Lege anschließend ein Korn ab.“

Hierfür gibt es die Fallunterscheidung, auch Konditional, Verzweigung, bedingte Anweisung genannt.

void main()
{
    nimm();
    if (vornFrei())
    {
        vor();
    }
    else
    {
        linksUm();
        vor();
    }
    gib();
}

6. Schleifen

void main()
{
    // Solange die
    // Bedingung
    // erfuellt ist, ...
    while (vornFrei())
    {
        // ...fuehre den
        // Schleifenrumpf
        // aus.
        vor();
    }
    nimm();
}

7. Logische Ausdrücke

Jeder Testbefehl wertet immer zu „wahr“ oder „falsch“ aus. In Java entspricht dies den beiden Wahrheitswerten true und false. Es ist möglich, mehrere Testbefehle zu kombinieren. Diese durch logische Operatoren kombinierten Testbefehle werden logische Ausdrücke genannt (das Gebiet der Logik beschäftigt sich mit wahren und falschen Aussagen):

void main()
{
    if (!maulLeer())
    {
        gib();
    }
}

Im rechtsstehenden Programm wird geprüft, ob „nicht das Maul leer ist“ − mit anderen Worten, ob der Hamster noch mindestens ein Korn in seinen Backen vorrätig hat. Falls dem so ist, legt er dieses Korn ab (Zeile 5).

Hinweis: Die Disjunktion, z.B. vornFrei() || maulLeer(), ist erfüllt, wenn mindestens eine der beiden Bedingungen erfüllt ist − insbesondere dürfen also auch beide Bedingungen erfüllt sein.

8. Schachtelung

void main()
{
    while (vornFrei())
    {
        vor();
        if (kornDa())
        {
            nimm();
        }
    }
}