Lernstrecke: Türme von Hanoi mit BlueJ und SuM

0. Vorbereitung

Öffne zuerst BlueJ und erstelle ein neues Projekt. Füge die Dateien Main.java und Scheibe.java ein. Kompiliere anschließend beide Klassen.

Start: Erzeuge in BlueJ ein Objekt der Klasse Main. Das Spielfeld erscheint automatisch. Einzelne Züge kannst du mit Methodenaufrufen testen:

ziehe(1, 3)
ziehe(1, 2)
zeigeHilfe()

Hinweis: Es gibt absichtlich keine main-Methode. In BlueJ startet das Programm durch das Erzeugen eines Objekts der Klasse Main.

Kompetenzziele

Objekte und Klassen

Du erkennst, welche Aufgaben die Klassen Main und Scheibe übernehmen.

Arrays

Du nutzt das Array scheibenArray, um alle Scheiben gemeinsam zu verwalten.

Stapel

Du verwendest die Datenstruktur Stapel, um die drei Türme zu modellieren.

Spielregeln

Du übersetzt Regeln des Spiels in Bedingungen und Methoden.

Phase 1: Programm starten und Oberfläche erkunden

Ziel: Du kannst das Programm starten, einzelne Züge ausführen und die wichtigsten Bereiche der Oberfläche benennen.

Auftrag 1.1: Starte das Programm in BlueJ durch new Main(). Rufe anschließend ziehe(1, 3) auf.

Auftrag 1.2: Notiere: Was bedeuten die Zahlen in ziehe(1, 3)?

Tipp

Die erste Zahl ist der Startstapel, die zweite Zahl der Zielstapel. ziehe(1, 3) bedeutet also: Ziehe die oberste Scheibe von Stapel 1 auf Stapel 3.

Checkliste

☐ Ich kann ein Objekt der Klasse Main erzeugen.
☐ Ich kann mit ziehe(von, nach) einen Zug testen.
☐ Ich kann erklären, warum keine main-Methode nötig ist.

Phase 2: Die zwei Klassen verstehen

Ziel: Du verstehst die Arbeitsteilung zwischen Main und Scheibe.

Klasse	Aufgabe	Typische Methoden
`Main`	Steuert das Spiel, verwaltet Stapel, prüft Regeln und zählt Züge.	`ziehe`, `istZugGueltig`, `istGewonnen`
`Scheibe`	Zeichnet, radiert und bewegt eine einzelne Scheibe.	`zeichne`, `radiere`, `bewegeZu`

Auftrag 2.1: Öffne beide Klassen. Markiere in jeder Klasse drei Methoden, die du schon ungefähr verstehst.

Auftrag 2.2: Erkläre schriftlich: Warum sollte Main nicht selbst jede Scheibe zeichnen?

Mögliche Antwortidee

Wenn jede Scheibe selbst weiß, wie sie gezeichnet und bewegt wird, bleibt die Klasse Main übersichtlicher. Main kümmert sich dann um die Spiellogik.

Phase 3: Stapel als Datenstruktur

Ziel: Du verstehst, warum die Türme von Hanoi gut mit Stapeln modelliert werden können.

Ein Stapel funktioniert nach dem Prinzip: Das zuletzt abgelegte Objekt wird zuerst wieder genommen. Bei Türme von Hanoi darf immer nur die oberste Scheibe bewegt werden. Genau deshalb passt ein Stapel sehr gut.

Wichtige Stapel-Methoden

Methode	Bedeutung im Spiel
`legeAuf(scheibe)`	Legt eine Scheibe oben auf einen Stapel.
`oberstes()`	Liefert die oberste Scheibe, ohne sie zu entfernen.
`nimmAb()`	Entfernt die oberste Scheibe.
`istLeer()`	Prüft, ob auf einem Stapel keine Scheibe liegt.
`laenge()`	Gibt an, wie viele Scheiben auf einem Stapel liegen.

Auftrag 3.1: Suche in Main die Stelle, an der meinStapel1, meinStapel2 und meinStapel3 erstellt werden.

Auftrag 3.2: Suche die Methode erstelleScheiben(). Erkläre, warum die größte Scheibe zuerst auf meinStapel1 gelegt wird.

Tipp

Wenn zuerst die größte Scheibe abgelegt wird, liegt sie unten. Danach kommen kleinere Scheiben darüber.

Phase 4: Einen Zug nachvollziehen

Ziel: Du kannst erklären, was bei einem Aufruf von ziehe(von, nach) passiert.

Auftrag 4.1: Lies die Methode ziehe von oben nach unten. Schreibe zu jedem Abschnitt eine kurze Erklärung.

Orientierung

Stapelnummern prüfen
Prüfen, ob Start und Ziel verschieden sind
Start- und Zielstapel bestimmen
Prüfen, ob auf dem Startstapel eine Scheibe liegt
Prüfen, ob der Zug erlaubt ist
Scheibe vom Startstapel nehmen
Neue Position berechnen
Scheibe bewegen und auf Zielstapel legen
Zugzähler erhöhen
Gewinnbedingung prüfen

Auftrag 4.2: Teste absichtlich ungültige Züge, zum Beispiel:

ziehe(2, 3)
ziehe(1, 1)

Notiere, welche Meldungen erscheinen.

Phase 5: Spielregel untersuchen und verändern

Ziel: Du verstehst die Methode istZugGueltig und kannst sie begründen.

return pScheibe.gibNummer() < obereZielScheibe.gibNummer();

In dieser Vorlage gilt: Eine kleinere Nummer bedeutet eine kleinere Scheibe. Scheibe 1 darf also auf Scheibe 2 liegen, aber Scheibe 5 darf nicht auf Scheibe 1 liegen.

Auftrag 5.1: Erstelle drei Beispiele für gültige und drei Beispiele für ungültige Züge. Begründe deine Entscheidung jeweils mit der Scheibennummer.

Auftrag 5.2: Ergänze in der Methode istZugGueltig einen eigenen Kommentar, der die Regel verständlich erklärt.

Phase 6: Design-Aufgaben

Ziel: Du kannst die grafische Darstellung verändern, ohne die Spielregeln kaputtzumachen.

Auftrag 6.1: Ändere die Farben der Scheiben im Array farben in der Methode erstelleScheiben().

Auftrag 6.2: Ändere die Formel in berechneBreite. Achte darauf, dass die größte Scheibe weiterhin nicht zu breit für das Spielfeld wird.

Auftrag 6.3: Ergänze in zeichneSpielfeld() eine zusätzliche Beschriftung der Türme, zum Beispiel A, B und C.

Tipp zum Zeichnen mit Buntstift

Nutze meinStift.bewegeBis(x, y), um den Stift zu positionieren, und anschließend meinStift.schreibeText("Text").

Phase 7: Gewinnbedingung und Zugzähler

Ziel: Du erkennst, wann das Spiel gewonnen wurde, und kannst den Zugzähler erklären.

Auftrag 7.1: Suche alle Stellen, an denen zugAnzahl verwendet wird. Erkläre, wann der Wert erhöht wird und wann nicht.

Auftrag 7.2: Suche die Methode istGewonnen(). Warum reicht es bei dieser Vorlage zunächst zu prüfen, ob meinStapel3.laenge() gleich der Anzahl der Scheiben ist?

Erklärung

Weil nur gültige Züge erlaubt sind, kann der dritte Stapel nicht falsch aufgebaut sein, wenn alle Scheiben dort liegen. Trotzdem kann man die Methode später noch genauer machen.

Phase 8: Erweiterungen für Fortgeschrittene

Ziel: Du wählst eine Erweiterung und setzt sie möglichst selbstständig um.

Challenge A: Animation

Erweitere Scheibe.bewegeZu, sodass die Scheibe erst nach oben, dann seitlich und dann nach unten fährt.

Challenge B: Mehr Scheiben

Mache die Anzahl der Scheiben veränderbar. Prüfe, ob Farben und Spielfeld noch passen.

Challenge C: Maussteuerung

Statt ziehe(1, 3) sollen Start- und Zielstapel mit der Maus ausgewählt werden.

Challenge D: Automatische Lösung

Programmiere eine rekursive Lösung. Nutze die Idee: loese(n, start, ziel, hilfe).

Challenge E: Minimum anzeigen

Berechne die minimale Zuganzahl mit der Formel 2^n - 1 und zeige sie an.

Challenge F: Fehlermeldungen

Gestalte ungültige Züge deutlicher, z.B. mit farbiger Meldungsfläche.

Kompletter Code zum Kopieren

Lege in BlueJ zwei Klassen mit den Namen Main und Scheibe an. Kopiere anschließend den passenden Code vollständig in die jeweilige Klasse.

Wichtig: Der Dateiname und der Klassenname müssen übereinstimmen. Die Klasse Main kommt also in Main.java, die Klasse Scheibe in Scheibe.java.

Main.java

import sum.kern.*;
import sum.werkzeuge.*;
import sum.strukturen.*;
import java.awt.Color;

/**
 * Tuerme von Hanoi - Vorlage fuer BlueJ und die SuM-Bibliothek.
 *
 * Start in BlueJ:
 * 1. Rechtsklick auf die Klasse Main.
 * 2. "new Main()" auswaehlen.
 * 3. Danach koennen Zuege z.B. mit ziehe(1, 3) ausgefuehrt werden.
 *
 * Didaktische Idee:
 * - Main steuert das Spiel.
 * - Scheibe zeichnet und bewegt eine einzelne Scheibe.
 * - Die drei Tuerme werden als Stapel modelliert.
 */
public class Main
{
    // ------------------------------------------------------------
    // Konstanten: Hier koennen spaeter Schwierigkeitsgrad und Design
    // veraendert werden.
    // ------------------------------------------------------------
    private static final int BILDSCHIRM_BREITE = 1280;
    private static final int BILDSCHIRM_HOEHE = 720;

    private static final int ANZAHL_SCHEIBEN = 5;

    private static final double STAPEL_1_X = 250;
    private static final double STAPEL_2_X = 640;
    private static final double STAPEL_3_X = 1030;

    private static final double BODEN_Y = 585;
    private static final double SCHEIBEN_HOEHE = 30;

    // ------------------------------------------------------------
    // Bezugsobjekte
    // ------------------------------------------------------------
    Bildschirm derBildschirm;
    Buntstift meinStift;

    Stapel<Scheibe> meinStapel1;
    Stapel<Scheibe> meinStapel2;
    Stapel<Scheibe> meinStapel3;

    Scheibe[] scheibenArray;

    int zugAnzahl;

    // ------------------------------------------------------------
    // Konstruktor
    // ------------------------------------------------------------
    public Main()
    {
        derBildschirm = new Bildschirm(BILDSCHIRM_BREITE, BILDSCHIRM_HOEHE);
        meinStift = new Buntstift();

        neuesSpiel();
    }

    // ------------------------------------------------------------
    // Spielstart und Aufbau
    // ------------------------------------------------------------

    /**
     * Setzt das Spiel komplett zurueck und baut die Startposition auf.
     */
    public void neuesSpiel()
    {
        zugAnzahl = 0;

        meinStapel1 = new Stapel<Scheibe>();
        meinStapel2 = new Stapel<Scheibe>();
        meinStapel3 = new Stapel<Scheibe>();

        scheibenArray = new Scheibe[ANZAHL_SCHEIBEN];

        derBildschirm.loescheAlles();

        erstelleScheiben();
        zeichneAlles();
        schreibeMeldung("Start: Nutze z.B. ziehe(1, 3). Ziel: alle Scheiben auf Stapel 3.");
    }

    /**
     * Erstellt die Scheiben und legt sie am Anfang alle auf Stapel 1.
     *
     * Nummer 1 ist die kleinste Scheibe.
     * Die groesste Scheibe wird zuerst auf den Stapel gelegt.
     */
    private void erstelleScheiben()
    {
        Color[] farben = {
            Farbe.rgb(230, 80, 80),
            Farbe.rgb(250, 170, 60),
            Farbe.rgb(240, 220, 80),
            Farbe.rgb(80, 170, 230),
            Farbe.rgb(130, 90, 210)
        };

        for(int nummer = ANZAHL_SCHEIBEN; nummer >= 1; nummer--)
        {
            double breite = berechneBreite(nummer);
            double x = STAPEL_1_X - breite / 2;
            double y = berechneScheibenY(meinStapel1.laenge());

            Scheibe neueScheibe = new Scheibe(nummer, breite, SCHEIBEN_HOEHE, farben[nummer - 1], x, y);

            scheibenArray[nummer - 1] = neueScheibe;
            meinStapel1.legeAuf(neueScheibe);
        }
    }

    /**
     * Berechnet die Breite aus der Scheibennummer.
     * TODO leicht: Aendere die Formel und beobachte, wie sich das Design veraendert.
     */
    private double berechneBreite(int pNummer)
    {
        return 80 + pNummer * 38;
    }

    /**
     * Berechnet die y-Position einer Scheibe auf einem Stapel.
     * pAnzahlScheibenDarunter gibt an, wie viele Scheiben bereits auf dem Zielstapel liegen.
     */
    private double berechneScheibenY(int pAnzahlScheibenDarunter)
    {
        return BODEN_Y - (pAnzahlScheibenDarunter + 1) * SCHEIBEN_HOEHE;
    }

    // ------------------------------------------------------------
    // Zuege und Spielregeln
    // ------------------------------------------------------------

    /**
     * Fuehrt einen Spielzug aus.
     *
     * Beispiele in BlueJ:
     * ziehe(1, 3)
     * ziehe(1, 2)
     * ziehe(3, 2)
     *
     * @param pVon Nummer des Startstapels: 1, 2 oder 3
     * @param pNach Nummer des Zielstapels: 1, 2 oder 3
     */
    public void ziehe(int pVon, int pNach)
    {
        if(!istStapelNummerGueltig(pVon) || !istStapelNummerGueltig(pNach))
        {
            schreibeMeldung("Ungueltige Stapelnummer. Erlaubt sind nur 1, 2 und 3.");
            return;
        }

        if(pVon == pNach)
        {
            schreibeMeldung("Ungueltiger Zug: Start und Ziel sind gleich.");
            return;
        }

        Stapel<Scheibe> startStapel = stapelVonNummer(pVon);
        Stapel<Scheibe> zielStapel = stapelVonNummer(pNach);

        if(startStapel.istLeer())
        {
            schreibeMeldung("Ungueltiger Zug: Auf Stapel " + pVon + " liegt keine Scheibe.");
            return;
        }

        Scheibe bewegteScheibe = startStapel.oberstes();

        if(!istZugGueltig(bewegteScheibe, zielStapel))
        {
            schreibeMeldung("Ungueltiger Zug: Eine groessere Scheibe darf nicht auf eine kleinere.");
            return;
        }

        // Datenstruktur veraendern:
        startStapel.nimmAb();

        // Neue sichtbare Position berechnen:
        double neueX = stapelX(pNach) - bewegteScheibe.gibBreite() / 2;
        double neueY = berechneScheibenY(zielStapel.laenge());

        // Darstellung veraendern:
        bewegteScheibe.bewegeZu(neueX, neueY);

        // Scheibe auf dem Zielstapel ablegen:
        zielStapel.legeAuf(bewegteScheibe);

        zugAnzahl++;

        zeichneAlles();
        schreibeMeldung("Gueltiger Zug: " + pVon + " -> " + pNach + ". Zuege: " + zugAnzahl);

        if(istGewonnen())
        {
            zeigeSiegesbildschirm();
        }
    }

    /**
     * Prueft die wichtigste Hanoi-Regel.
     *
     * TODO mittel:
     * Lies diese Methode genau.
     * Erklaere in eigenen Worten, warum ein leerer Zielstapel immer erlaubt ist.
     */
    private boolean istZugGueltig(Scheibe pScheibe, Stapel<Scheibe> pZielStapel)
    {
        if(pZielStapel.istLeer())
        {
            return true;
        }

        Scheibe obereZielScheibe = pZielStapel.oberstes();

        // Kleine Nummer bedeutet kleine Scheibe.
        return pScheibe.gibNummer() < obereZielScheibe.gibNummer();
    }

    /**
     * Prueft, ob alle Scheiben auf Stapel 3 liegen.
     *
     * TODO mittel:
     * Erweitere die Pruefung so, dass zusaetzlich die Reihenfolge kontrolliert wird.
     */
    private boolean istGewonnen()
    {
        return meinStapel3.laenge() == ANZAHL_SCHEIBEN;
    }

    // ------------------------------------------------------------
    // Optionale Eingabe ueber Dialogfenster
    // ------------------------------------------------------------

    /**
     * Startet eine einfache Eingabe-Schleife mit Dialogfenstern.
     *
     * 0 als Startstapel beendet die Eingabe.
     *
     * Diese Methode ist optional. Fuer den Anfang reicht es,
     * einzelne Zuege in BlueJ mit ziehe(1, 3) aufzurufen.
     */
    public void spieleMitDialogen()
    {
        while(!istGewonnen())
        {
            int von = derBildschirm.holeGanzeZahl("Von welchem Stapel ziehen? 1, 2, 3 oder 0 fuer Ende");

            if(von == 0)
            {
                schreibeMeldung("Eingabe beendet. Du kannst weiter mit ziehe(von, nach) spielen.");
                return;
            }

            int nach = derBildschirm.holeGanzeZahl("Auf welchen Stapel ziehen? 1, 2 oder 3");

            ziehe(von, nach);
        }
    }

    /**
     * TODO schwer:
     * Programmiere hier spaeter eine automatische Loesung mit Rekursion.
     *
     * Tipp:
     * loese(n, start, ziel, hilfe)
     */
    public void automatischeLoesung()
    {
        schreibeMeldung("TODO schwer: Automatische Loesung mit Rekursion programmieren.");
    }

    // ------------------------------------------------------------
    // Zeichnen
    // ------------------------------------------------------------

    /**
     * Zeichnet den kompletten aktuellen Spielzustand neu.
     */
    private void zeichneAlles()
    {
        derBildschirm.loescheAlles();

        zeichneSpielfeld();
        zeichneAlleScheiben();
        zeichneKopfbereich();
    }

    /**
     * Zeichnet die drei Tuerme und die Bodenplatte.
     */
    private void zeichneSpielfeld()
    {
        meinStift.setzeFuellmuster(Muster.GEFUELLT);

        // Hintergrund
        meinStift.setzeFarbe(Farbe.rgb(245, 248, 255));
        meinStift.bewegeBis(0, 0);
        meinStift.zeichneRechteck(BILDSCHIRM_BREITE, BILDSCHIRM_HOEHE);

        // Bodenplatte
        meinStift.setzeFarbe(Farbe.rgb(110, 80, 55));
        meinStift.bewegeBis(130, BODEN_Y);
        meinStift.zeichneRechteck(1020, 18);

        zeichneEinenStapel(STAPEL_1_X, "meinStapel1");
        zeichneEinenStapel(STAPEL_2_X, "meinStapel2");
        zeichneEinenStapel(STAPEL_3_X, "meinStapel3");

        // TODO leicht: Beschrifte die Stapel zusaetzlich mit A, B und C.
    }

    /**
     * Zeichnet einen einzelnen Turm.
     */
    private void zeichneEinenStapel(double pX, String pName)
    {
        meinStift.setzeFuellmuster(Muster.GEFUELLT);
        meinStift.setzeFarbe(Farbe.rgb(120, 90, 65));
        meinStift.bewegeBis(pX - 8, 300);
        meinStift.zeichneRechteck(16, BODEN_Y - 300);

        meinStift.setzeFarbe(Farbe.SCHWARZ);
        meinStift.bewegeBis(pX - 55, BODEN_Y + 45);
        meinStift.schreibeText(pName);
    }

    /**
     * Zeichnet alle Scheiben. Die groesseren Scheiben werden zuerst gezeichnet.
     */
    private void zeichneAlleScheiben()
    {
        for(int i = ANZAHL_SCHEIBEN - 1; i >= 0; i--)
        {
            scheibenArray[i].zeichne();
        }
    }

    /**
     * Zeichnet Ueberschrift, Zugzaehler und kurze Hilfe.
     */
    private void zeichneKopfbereich()
    {
        meinStift.setzeFarbe(Farbe.SCHWARZ);

        meinStift.bewegeBis(40, 40);
        meinStift.schreibeText("Tuerme von Hanoi");

        meinStift.bewegeBis(40, 70);
        meinStift.schreibeText("Zuege: " + zugAnzahl);

        meinStift.bewegeBis(250, 70);
        meinStift.schreibeText("Beispielzug in BlueJ: ziehe(1, 3)");
    }

    /**
     * Schreibt unten eine Rueckmeldung.
     */
    private void schreibeMeldung(String pText)
    {
        meinStift.setzeFuellmuster(Muster.GEFUELLT);
        meinStift.setzeFarbe(Farbe.rgb(245, 248, 255));
        meinStift.bewegeBis(20, 635);
        meinStift.zeichneRechteck(1240, 55);

        meinStift.setzeFarbe(Farbe.SCHWARZ);
        meinStift.bewegeBis(40, 670);
        meinStift.schreibeText(pText);
    }

    /**
     * Zeigt den Siegesbildschirm.
     */
    private void zeigeSiegesbildschirm()
    {
        derBildschirm.loescheAlles();

        meinStift.setzeFuellmuster(Muster.GEFUELLT);
        meinStift.setzeFarbe(Farbe.rgb(230, 255, 230));
        meinStift.bewegeBis(0, 0);
        meinStift.zeichneRechteck(BILDSCHIRM_BREITE, BILDSCHIRM_HOEHE);

        meinStift.setzeFarbe(Farbe.rgb(30, 120, 60));
        meinStift.bewegeBis(390, 250);
        meinStift.schreibeText("Gewonnen!");

        meinStift.bewegeBis(390, 300);
        meinStift.schreibeText("Du hast " + zugAnzahl + " Zuege gebraucht.");

        meinStift.setzeFarbe(Farbe.SCHWARZ);
        meinStift.bewegeBis(390, 350);
        meinStift.schreibeText("Minimum bei 5 Scheiben: 31 Zuege.");

        meinStift.bewegeBis(390, 420);
        meinStift.schreibeText("Mit neuesSpiel() kannst du neu starten.");
    }

    // ------------------------------------------------------------
    // Hilfsmethoden
    // ------------------------------------------------------------

    private boolean istStapelNummerGueltig(int pNummer)
    {
        return pNummer == 1 || pNummer == 2 || pNummer == 3;
    }

    private Stapel<Scheibe> stapelVonNummer(int pNummer)
    {
        if(pNummer == 1)
        {
            return meinStapel1;
        }

        if(pNummer == 2)
        {
            return meinStapel2;
        }

        return meinStapel3;
    }

    private double stapelX(int pNummer)
    {
        if(pNummer == 1)
        {
            return STAPEL_1_X;
        }

        if(pNummer == 2)
        {
            return STAPEL_2_X;
        }

        return STAPEL_3_X;
    }

    /**
     * Gibt eine kurze Hilfe auf dem Bildschirm aus.
     */
    public void zeigeHilfe()
    {
        schreibeMeldung("Nutze ziehe(von, nach), z.B. ziehe(1, 3). Nur kleine Scheiben duerfen auf grosse.");
    }

    /**
     * Schliesst das SuM-Fenster.
     */
    public void beenden()
    {
        derBildschirm.gibFrei();
    }
}

Tipp: In BlueJ zuerst die Klasse Main öffnen, alten Inhalt markieren und dann diesen Code einfügen.

Scheibe.java

import sum.kern.*;
import sum.werkzeuge.*;
import java.awt.Color;

/**
 * Eine Scheibe im Spiel Tuerme von Hanoi.
 *
 * Diese Klasse ist fuer Darstellung und Bewegung einer einzelnen Scheibe
 * verantwortlich. Die Spielregeln liegen in der Klasse Main.
 */
public class Scheibe
{
    // ------------------------------------------------------------
    // Eigenschaften
    // ------------------------------------------------------------
    Buntstift meinStift;
    Uhr meineUhr;

    int nummer;
    double breite;
    double hoehe;
    Color farbe;

    double x;
    double y;

    // ------------------------------------------------------------
    // Konstruktor
    // ------------------------------------------------------------
    public Scheibe(int pNummer, double pBreite, double pHoehe, Color pFarbe, double pX, double pY)
    {
        nummer = pNummer;
        breite = pBreite;
        hoehe = pHoehe;
        farbe = pFarbe;

        x = pX;
        y = pY;

        meinStift = new Buntstift();
        meineUhr = new Uhr();
    }

    // ------------------------------------------------------------
    // Darstellung
    // ------------------------------------------------------------

    /**
     * Zeichnet die Scheibe an ihrer aktuellen Position.
     */
    public void zeichne()
    {
        meinStift.setzeFuellmuster(Muster.GEFUELLT);

        // Scheibenkoerper
        meinStift.setzeFarbe(farbe);
        meinStift.bewegeBis(x, y);
        meinStift.zeichneRechteck(breite, hoehe);

        // Rand
        meinStift.setzeFuellmuster(Muster.DURCHSICHTIG);
        meinStift.setzeFarbe(Farbe.SCHWARZ);
        meinStift.bewegeBis(x, y);
        meinStift.zeichneRechteck(breite, hoehe);

        // Nummer
        meinStift.setzeFarbe(Farbe.SCHWARZ);
        meinStift.bewegeBis(x + breite / 2 - 5, y + 20);
        meinStift.schreibeZahl(nummer);
    }

    /**
     * Radiert die Scheibe mit der Hintergrundfarbe.
     *
     * Hinweis:
     * Nach einem Zug zeichnet Main das komplette Spielfeld neu.
     */
    public void radiere()
    {
        meinStift.setzeFuellmuster(Muster.GEFUELLT);
        meinStift.setzeFarbe(Farbe.rgb(245, 248, 255));
        meinStift.bewegeBis(x - 2, y - 2);
        meinStift.zeichneRechteck(breite + 4, hoehe + 4);
    }

    // ------------------------------------------------------------
    // Bewegung
    // ------------------------------------------------------------

    /**
     * Bewegt die Scheibe zu einer neuen Position.
     *
     * Diese einfache Version springt fast direkt zur Zielposition.
     *
     * TODO schwer:
     * Ersetze diese Methode spaeter durch eine schoene Animation:
     * 1. nach oben bewegen
     * 2. seitlich bewegen
     * 3. nach unten bewegen
     */
    public void bewegeZu(double pNeuesX, double pNeuesY)
    {
        radiere();

        x = pNeuesX;
        y = pNeuesY;

        zeichne();
        meineUhr.warte(120);
    }

    /**
     * Optionaler Hilfsdienst fuer eine spaetere Animation.
     *
     * TODO schwer:
     * Nutze diesen Dienst in bewegeZu(...), um die Scheibe in kleinen Schritten
     * zu bewegen.
     */
    public void bewegeSchrittweiseZu(double pNeuesX, double pNeuesY)
    {
        // Noch nicht fertig. Diese Methode ist als Erweiterungsaufgabe gedacht.
        bewegeZu(pNeuesX, pNeuesY);
    }

    // ------------------------------------------------------------
    // Getter-Methoden
    // ------------------------------------------------------------

    public int gibNummer()
    {
        return nummer;
    }

    public double gibBreite()
    {
        return breite;
    }

    public double gibHoehe()
    {
        return hoehe;
    }

    public double gibX()
    {
        return x;
    }

    public double gibY()
    {
        return y;
    }
}

Tipp: Danach kompilieren. Gestartet wird das Projekt über new Main().

Abschlussreflexion

Beantworte am Ende kurz diese Fragen:

Welche Aufgabe hat die Klasse Main?
Welche Aufgabe hat die Klasse Scheibe?
Warum passt die Datenstruktur Stapel besonders gut zu Türme von Hanoi?
Welche Bedingung verhindert ungültige Züge?
Welche Erweiterung würdest du als nächstes einbauen?