Wordle 4: Das Spiel als Objekt
In Teil 3 steckt das ganze Spiel in main: ein Zähler für die Versuche, ein
boolean für „gelöst“, das gesuchte Wort als Konstante, die Muster als Texte aus
+, ? und -. Mit dem, was du über eigene Klassen gelernt hast, bauen wir
daraus jetzt Objekte – genau nach dem Entwurf aus der Übung im Kapitel
Denken in Objekten.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einen vorgegebenen Entwurf in Enums, einen Record und eine Klasse umsetzen
- eine Klasse ihre Spielregeln selbst durchsetzen lassen
- mit vorgegebenen Tests prüfen, ob die Umsetzung stimmt
- die Konsole so umbauen, dass sie nur noch das
Spielbenutzt
Ausgangsstand für wordle
⤓ wordle-4.zip herunterladenWer die letzte Stufe nicht fertig hat, startet hiermit: Rechtsklick auf das Projektwordle → Import… → General → Archive File → die ZIP-Datei wählen →Finish. Vorhandene Dateien werden dabei – nach Rückfrage – überschrieben.
Enthält: Wordle.java, WordleKonsole.java, WordleTest.java
Der Entwurf
Abschnitt betitelt „Der Entwurf“Vier neue Typen im Package de.drv.wordle:
| Typ | Art | Aufgabe |
|---|---|---|
Feld |
Enum | die Bewertung eines Buchstabens: Treffer, kommt vor, fehlt |
Status |
Enum | läuft, gewonnen oder verloren |
Bewertung |
Record | ein Versuch und sein Muster |
Spiel |
Klasse | kennt die Lösung, zählt die Versuche, entscheidet über Sieg und Niederlage |
Die Funktion Wordle.bewerte aus Teil 1 und 2 bleibt, wie sie ist – mit
allen zwölf Tests. Das Spiel benutzt sie.
public enum Feld { TREFFER('+'), ENTHALTEN('?'), FEHLT('-');
public char getZeichen() // das Zeichen im Muster public static Feld vonZeichen(char zeichen) // das Feld zu einem Zeichen}Ein unbekanntes Zeichen bei vonZeichen führt zu einer
IllegalArgumentException.
public enum Status { LAEUFT, GEWONNEN, VERLOREN}Bewertung
Abschnitt betitelt „Bewertung“public record Bewertung(String versuch, String muster) {
public Feld feld(int position) // das Feld an dieser Position public boolean istGeloest() // true, wenn das Muster nur aus '+' besteht}Sind Versuch und Muster nicht gleich lang, lehnt der kompakte Konstruktor die
Bewertung mit einer IllegalArgumentException ab.
public class Spiel { public static final int WORTLAENGE = 5; public static final int MAX_VERSUCHE = 6;
public Spiel(String loesung) public Bewertung rate(String versuch) public Status getStatus() public int getAnzahlVersuche() public String getAufloesung()}Die Regeln:
- Ein neues Spiel läuft und hat 0 Versuche. Eine Lösung, die nicht genau
5 Buchstaben hat, wird mit einer
IllegalArgumentExceptionabgelehnt. ratebewertet den Versuch mitWordle.bewerte, zählt ihn und liefert dieBewertung.- Ist der Versuch gelöst, ist das Spiel gewonnen. Ist es der sechste Versuch und nicht gelöst, ist es verloren.
ratenach Spielende löst eineIllegalStateExceptionaus.getAufloesung()verrät die Lösung erst nach Spielende – vorher gibt es eineIllegalStateException.
Die Tests
Abschnitt betitelt „Die Tests“Für die neuen Typen gibt es fertige Tests. Lege sie im Ordner test an – sie
werden zunächst nicht einmal übersetzen, weil es die Klassen noch nicht gibt.
Deine Aufgabe: Schreibe Feld, Status, Bewertung und Spiel so, dass
alle Tests grün werden – die neuen und die zwölf alten.
BewertungTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
class BewertungTest {
@Test @DisplayName("Jedes Feld hat sein Zeichen – und umgekehrt") void feldUndZeichen() { assertEquals('+', Feld.TREFFER.getZeichen()); assertEquals('?', Feld.ENTHALTEN.getZeichen()); assertEquals('-', Feld.FEHLT.getZeichen()); assertEquals(Feld.TREFFER, Feld.vonZeichen('+')); assertEquals(Feld.ENTHALTEN, Feld.vonZeichen('?')); assertEquals(Feld.FEHLT, Feld.vonZeichen('-')); }
@Test @DisplayName("Ein unbekanntes Zeichen ist kein Feld") void unbekanntesZeichen() { assertThrows(IllegalArgumentException.class, () -> Feld.vonZeichen('x')); }
@Test @DisplayName("Die Felder einer Bewertung") void felder() { Bewertung bewertung = new Bewertung("ADIEU", "---+?"); assertEquals(Feld.FEHLT, bewertung.feld(0)); assertEquals(Feld.TREFFER, bewertung.feld(3)); assertEquals(Feld.ENTHALTEN, bewertung.feld(4)); }
@Test @DisplayName("Gelöst nur, wenn alle Felder Treffer sind") void geloest() { assertTrue(new Bewertung("FEUER", "+++++").istGeloest()); assertFalse(new Bewertung("FEUER", "++++?").istGeloest()); }
@Test @DisplayName("Gleiche Bewertungen sind gleich") void gleichheit() { assertEquals(new Bewertung("ADIEU", "---+?"), new Bewertung("ADIEU", "---+?")); }
@Test @DisplayName("Versuch und Muster müssen gleich lang sein") void ungleicheLaenge() { assertThrows(IllegalArgumentException.class, () -> new Bewertung("ADIEU", "---")); }
}SpielTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
class SpielTest {
@Test @DisplayName("Ein neues Spiel läuft und hat noch keine Versuche") void neuesSpiel() { Spiel spiel = new Spiel("FEUER"); assertEquals(Status.LAEUFT, spiel.getStatus()); assertEquals(0, spiel.getAnzahlVersuche()); }
@Test @DisplayName("Ein Versuch liefert seine Bewertung und wird gezählt") void versuch() { Spiel spiel = new Spiel("FEUER"); assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate("ADIEU")); assertEquals(1, spiel.getAnzahlVersuche()); assertEquals(Status.LAEUFT, spiel.getStatus()); }
@Test @DisplayName("Wer das Wort errät, gewinnt") void gewonnen() { Spiel spiel = new Spiel("FEUER"); spiel.rate("ADIEU"); spiel.rate("FEUER"); assertEquals(Status.GEWONNEN, spiel.getStatus()); assertEquals(2, spiel.getAnzahlVersuche()); }
@Test @DisplayName("Nach sechs Fehlversuchen ist das Spiel verloren") void verloren() { Spiel spiel = new Spiel("FEUER"); for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) { spiel.rate("ADIEU"); } assertEquals(Status.VERLOREN, spiel.getStatus()); }
@Test @DisplayName("Ein Treffer im letzten Versuch gewinnt noch") void gewonnenImLetztenVersuch() { Spiel spiel = new Spiel("FEUER"); for (int i = 0; i < Spiel.MAX_VERSUCHE - 1; i++) { spiel.rate("ADIEU"); } spiel.rate("FEUER"); assertEquals(Status.GEWONNEN, spiel.getStatus()); }
@Test @DisplayName("Nach Spielende kann nicht weiter geraten werden") void keinVersuchNachSpielende() { Spiel spiel = new Spiel("FEUER"); spiel.rate("FEUER"); assertThrows(IllegalStateException.class, () -> spiel.rate("ADIEU")); assertEquals(1, spiel.getAnzahlVersuche()); }
@Test @DisplayName("Die Lösung wird erst nach Spielende verraten") void aufloesung() { Spiel spiel = new Spiel("FEUER"); assertThrows(IllegalStateException.class, () -> spiel.getAufloesung()); for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) { spiel.rate("ADIEU"); } assertEquals("FEUER", spiel.getAufloesung()); }
@Test @DisplayName("Eine Lösung mit falscher Länge wird abgelehnt") void falscheLoesung() { assertThrows(IllegalArgumentException.class, () -> new Spiel("HALLOO")); }
}Hinweise
Abschnitt betitelt „Hinweise“Wie findet vonZeichen das passende Feld?
values() liefert alle Felder. Durchlaufe sie und gib das zurück, dessen
Zeichen passt. Findet die Schleife keins, ist das Zeichen ungültig.
Gewonnen oder verloren – in welcher Reihenfolge prüfen?
Erst auf gewonnen prüfen, dann auf verloren. Sonst wird ein Treffer im sechsten Versuch als Niederlage gewertet. Der Test „Ein Treffer im letzten Versuch gewinnt noch“ achtet genau darauf.
Welche Felder braucht das Spiel?
Die Lösung (final), die Anzahl der Versuche und den Status. Die einzelnen
Bewertungen muss sich das Spiel nicht merken – die bekommt der Aufrufer von
rate zurück.
Lösung
package de.drv.wordle;
public enum Feld {
TREFFER('+'), ENTHALTEN('?'), FEHLT('-');
private final char zeichen;
Feld(char zeichen) { this.zeichen = zeichen; }
public char getZeichen() { return zeichen; }
public static Feld vonZeichen(char zeichen) { for (Feld feld : values()) { if (feld.zeichen == zeichen) { return feld; } } throw new IllegalArgumentException("Unbekanntes Zeichen im Muster: " + zeichen); }
}Lösung
package de.drv.wordle;
public record Bewertung(String versuch, String muster) {
public Bewertung { if (versuch == null || muster == null || versuch.length() != muster.length()) { throw new IllegalArgumentException("Versuch und Muster müssen gleich lang sein."); } }
public Feld feld(int position) { return Feld.vonZeichen(muster.charAt(position)); }
public boolean istGeloest() { return muster.equals("+".repeat(muster.length())); }
}Lösung
rate prüft zuerst, ob das Spiel noch läuft – erst prüfen, dann verändern, wie
beim Konto. Der Zähler wird nur erhöht, wenn der Versuch wirklich bewertet wurde.
package de.drv.wordle;
public class Spiel {
public static final int WORTLAENGE = 5; public static final int MAX_VERSUCHE = 6;
private final String loesung; private int anzahlVersuche; private Status status;
public Spiel(String loesung) { if (loesung == null || loesung.length() != WORTLAENGE) { throw new IllegalArgumentException("Die Lösung muss " + WORTLAENGE + " Buchstaben haben."); } this.loesung = loesung.toUpperCase(); this.anzahlVersuche = 0; this.status = Status.LAEUFT; }
public Bewertung rate(String versuch) { if (status != Status.LAEUFT) { throw new IllegalStateException("Das Spiel ist bereits vorbei."); } Bewertung bewertung = new Bewertung(versuch, Wordle.bewerte(versuch, loesung)); anzahlVersuche++; if (bewertung.istGeloest()) { status = Status.GEWONNEN; } else if (anzahlVersuche == MAX_VERSUCHE) { status = Status.VERLOREN; } return bewertung; }
public Status getStatus() { return status; }
public int getAnzahlVersuche() { return anzahlVersuche; }
public String getAufloesung() { if (status == Status.LAEUFT) { throw new IllegalStateException("Die Lösung wird erst nach Spielende verraten."); } return loesung; }
}Die Konsole umbauen
Abschnitt betitelt „Die Konsole umbauen“Die Konsole aus Teil 3 rechnet noch selbst mit Zähler und boolean. Baue sie so
um, dass sie nur noch das Spiel benutzt:
- Die Schleife läuft, solange
spiel.getStatus() == Status.LAEUFT. - Nach dem Spiel entscheidet ein
switchüber den Status, welche Meldung erscheint. - Die farbige Ausgabe aus Teil 3 wählt die Farbe jetzt mit einem
switchüberbewertung.feld(i)– ohnedefault.
Lösung
Vergleiche die beiden switch-Ausdrücke mit der Fassung aus Teil 3: Dort stand
default -> GRAU, weil der Compiler nicht wissen konnte, welche Zeichen im
Muster vorkommen. Über ein Enum weiß er es – und meldet sich, falls je ein
viertes Feld dazukommt.
Auch die Konstanten WORTLAENGE und MAX_VERSUCHE kommen jetzt aus Spiel
statt aus der Konsole: Die Regeln gehören zum Spiel, nicht zur Anzeige.
package de.drv.wordle;
import java.util.Scanner;
public class WordleKonsole {
private static final String GRUEN = "\u001B[30;42m"; private static final String GELB = "\u001B[30;43m"; private static final String GRAU = "\u001B[30;47m"; private static final String ZURUECK = "\u001B[0m";
public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Spiel spiel = new Spiel("FEUER");
System.out.println("WORDLE – errate das Wort mit " + Spiel.WORTLAENGE + " Buchstaben."); System.out.println();
while (spiel.getStatus() == Status.LAEUFT) { System.out.print("Versuch " + (spiel.getAnzahlVersuche() + 1) + "/" + Spiel.MAX_VERSUCHE + ": "); String eingabe = scanner.nextLine().strip().toUpperCase();
if (eingabe.length() != Spiel.WORTLAENGE) { System.out.println("Bitte genau " + Spiel.WORTLAENGE + " Buchstaben eingeben."); } else { Bewertung bewertung = spiel.rate(eingabe); System.out.println(" " + farbig(bewertung)); } }
System.out.println(); String meldung = switch (spiel.getStatus()) { case GEWONNEN -> "Gelöst mit " + spiel.getAnzahlVersuche() + " Versuch(en)!"; case VERLOREN -> "Leider nicht geschafft. Gesucht war: " + spiel.getAufloesung(); case LAEUFT -> "Das Spiel läuft noch."; }; System.out.println(meldung);
scanner.close(); }
public static String farbig(Bewertung bewertung) { StringBuilder ergebnis = new StringBuilder(); for (int i = 0; i < bewertung.versuch().length(); i++) { String farbe = switch (bewertung.feld(i)) { case TREFFER -> GRUEN; case ENTHALTEN -> GELB; case FEHLT -> GRAU; }; ergebnis.append(farbe).append(' ').append(bewertung.versuch().charAt(i)).append(' ').append(ZURUECK); } return ergebnis.toString(); }
}Übungen
Abschnitt betitelt „Übungen“-
Ergänze das
Spielum eine MethodegetVerbleibendeVersuche()und zeige in der Konsole „noch 4 Versuche“ an. Schreibe zuerst einen Test.Lösung
public int getVerbleibendeVersuche() {return MAX_VERSUCHE - anzahlVersuche;}Eine neue Methode hinzuzufügen ändert nichts an dem, was es schon gibt – alle bisherigen Tests und die Konsole funktionieren unverändert weiter.
-
Verlauf: Merke dir in der Konsole alle Bewertungen in einem Array
Bewertung[]und gib nach jedem Versuch den ganzen Verlauf farbig aus. -
Versuche, in der Konsole während des Spiels
spiel.getAufloesung()auszugeben. Was passiert? Und wo steht das gesuchte Wort trotzdem noch im Klartext?Lösung
Während das Spiel läuft, bricht
getAufloesung()mit einerIllegalStateExceptionab. Im Klartext steht das Wort aber immer noch in der Konsole:new Spiel("FEUER"). Wer den Quelltext – oder die übersetzte.class-Datei – hat, kann es lesen. Wie man das ändert, ist eine Frage für später.