Zum Inhalt springen

Wordle 5: Dienst und Wortquelle

Unser Spiel ist ein sauberes Objekt geworden. Drei Dinge stören aber noch:

  1. Die Konsole prüft die Eingaben selbst – ob ein Wort fünf Buchstaben hat, ist aber eine Spielregel. Sie gehört ins Spiel.
  2. Das gesuchte Wort steht fest in der Konsole. Für ein neues Wort muss man das Programm ändern.
  3. Die Konsole erzeugt das Spiel selbst – und hängt damit fest an genau dieser Klasse.

In diesem Teil beheben wir alle drei – mit dem, was du über Exceptions und Interfaces gelernt hast.

  • Regeln dort prüfen, wo sie hingehören, und Fehler per Exception melden
  • ein Interface für eine austauschbare Wortquelle schreiben und umsetzen
  • ein Programm so aufbauen, dass die Oberfläche nur noch ein Interface kennt

Ausgangsstand für wordle

⤓ wordle-5.zip herunterladen

Wer 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, Feld.java, Status.java, Bewertung.java, Spiel.java, WordleKonsole.java, WordleTest.java, BewertungTest.java, SpielTest.java

rate nimmt jetzt jede Eingabe entgegen und kümmert sich selbst darum:

  1. Leerzeichen am Rand entfernen und in Großbuchstaben umwandeln – " adieu " zählt wie "ADIEU".
  2. Hat das Wort nicht genau WORTLAENGE Zeichen: IllegalArgumentException mit der Meldung „Bitte genau 5 Buchstaben eingeben.“
  3. Enthält es etwas anderes als Buchstaben: IllegalArgumentException mit der Meldung „Bitte nur Buchstaben eingeben.“
  4. Ein abgelehnter Versuch wird nicht gezählt.

Die Konsole fängt die Exception und zeigt ihre Meldung an – sie muss die Regeln gar nicht mehr kennen:

try {
Bewertung bewertung = dienst.rate(id, eingabe);
System.out.println(" " + farbig(bewertung));
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}

So stehen die Regeln an einer Stelle. Ändert sich die Wortlänge, ändert sich die Meldung automatisch mit.

Woher das gesuchte Wort kommt, soll austauschbar sein – heute eine feste Liste, morgen vielleicht etwas anderes. Genau dafür gibt es Interfaces:

Wortquelle.java
package de.drv.wordle;
public interface Wortquelle {
String naechstesWort();
}

Die erste Umsetzung liefert die Wörter einer festen Liste reihum:

Wortquelle quelle = new FesteWortquelle(new String[] {"FEUER", "BLAUE", "KANNE"});
quelle.naechstesWort(); // FEUER
quelle.naechstesWort(); // BLAUE
quelle.naechstesWort(); // KANNE
quelle.naechstesWort(); // FEUER

Jetzt der wichtigste Schritt. Die Konsole soll nicht mehr selbst ein Spiel erzeugen, sondern einen Dienst fragen. Was ein Dienst können muss, legt ein Interface fest:

SpielDienst.java
package de.drv.wordle;
public interface SpielDienst {
/** Startet ein neues Spiel und liefert seine ID. */
String neuesSpiel();
/** Bewertet einen Versuch im angegebenen Spiel. */
Bewertung rate(String spielId, String versuch);
/** Der aktuelle Stand des Spiels; die Auflösung erst nach Spielende. */
SpielStand stand(String spielId);
}
SpielStand.java
package de.drv.wordle;
public record SpielStand(int versuche, int maxVersuche, Status status, String aufloesung) {
}
  • Ein Dienst kann mehrere Spiele gleichzeitig führen. Jedes bekommt eine ID – einen Text, über den es später wiedergefunden wird.
  • SpielStand fasst zusammen, was die Konsole über ein Spiel wissen muss – auch die Höchstzahl der Versuche, damit sie „Versuch 3/6“ anzeigen kann, ohne die Klasse Spiel zu kennen. Die aufloesung ist null, solange das Spiel läuft.
  • Eine unbekannte ID führt zu einer IllegalArgumentException.

LokalerSpielDienst setzt das Interface um. Er bekommt eine Wortquelle im Konstruktor und merkt sich seine Spiele. Dafür benutzen wir zwei fertige Werkzeuge der Standardbibliothek, die wir in der zweiten Woche genauer kennenlernen:

private final Map<String, Spiel> spiele = new HashMap<>();

Eine Map ordnet Schlüsseln Werte zu – hier jeder Spiel-ID ihr Spiel. spiele.put(id, spiel) legt ein Spiel ab, spiele.get(id) holt es wieder – oder liefert null, wenn es die ID nicht gibt.

String id = UUID.randomUUID().toString();

UUID erzeugt eine weltweit eindeutige, zufällige ID wie 3f2b8c1e-7a4d-4e2f-9b1a-0c5d6e7f8a9b. Warum nicht einfach 1, 2, 3? Fortlaufende Nummern lassen sich leicht erraten – zufällige IDs nicht.

WordleKonsole.java (Ausschnitt)
public class WordleKonsole {
private final SpielDienst dienst;
private final Scanner scanner;
public WordleKonsole(SpielDienst dienst, Scanner scanner) {
this.dienst = dienst;
this.scanner = scanner;
}
// …
}

Die Konsole bekommt ihren Dienst im Konstruktor übergeben. Sie weiß nicht, welche Klasse dahintersteckt – nur, dass er den Vertrag SpielDienst erfüllt. Zusammengesetzt wird alles an einer Stelle, in einer eigenen Startklasse:

WordleStart.java
package de.drv.wordle;
import java.util.Scanner;
public class WordleStart {
public static void main(String[] args) {
Wortquelle woerter = new FesteWortquelle(new String[] {"FEUER", "BLAUE", "KANNE"});
SpielDienst dienst = new LokalerSpielDienst(woerter);
try (Scanner scanner = new Scanner(System.in)) {
new WordleKonsole(dienst, scanner).spielen();
}
}
}
WordleStart ── erzeugt ──▶ FesteWortquelle, LokalerSpielDienst, WordleKonsole
WordleKonsole ──kennt nur──▶ «interface» SpielDienst
▲
LokalerSpielDienst ──kennt──▶ «interface» Wortquelle
│ ▲
▼ FesteWortquelle
Spiel

Wer ein anderes Wort, eine andere Wortquelle oder einen anderen Dienst will, ändert nur WordleStart. Die Konsole bleibt, wie sie ist.

Für Schritt 1 kommen drei Tests zu SpielTest hinzu, für die Schritte 2 und 3 gibt es eine neue Testklasse. Alle bisherigen Tests laufen unverändert weiter.

Neue Tests in SpielTest.java
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"));
}
@Test
@DisplayName("Eingaben werden bereinigt und großgeschrieben")
void eingabeBereinigt() {
Spiel spiel = new Spiel("FEUER");
assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate(" adieu "));
spiel.rate("feuer");
assertEquals(Status.GEWONNEN, spiel.getStatus());
}
@Test
@DisplayName("Ein Versuch mit falscher Länge wird abgelehnt und nicht gezählt")
void falscheLaenge() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalArgumentException.class, () -> spiel.rate("HAL"));
assertEquals(0, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Ein Versuch mit anderen Zeichen als Buchstaben wird abgelehnt")
void keineBuchstaben() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalArgumentException.class, () -> spiel.rate("FEU3R"));
assertThrows(IllegalArgumentException.class, () -> spiel.rate("FE ER"));
assertEquals(0, spiel.getAnzahlVersuche());
}
}
LokalerSpielDienstTest.java
LokalerSpielDienstTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
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 LokalerSpielDienstTest {
private SpielDienst dienst() {
return new LokalerSpielDienst(new FesteWortquelle(new String[] {"FEUER", "BLAUE"}));
}
@Test
@DisplayName("Jedes neue Spiel bekommt eine eigene ID")
void eigeneIds() {
SpielDienst dienst = dienst();
assertNotEquals(dienst.neuesSpiel(), dienst.neuesSpiel());
}
@Test
@DisplayName("Ein neues Spiel läuft, die Auflösung ist noch geheim")
void neuerStand() {
SpielDienst dienst = dienst();
String id = dienst.neuesSpiel();
assertEquals(new SpielStand(0, Spiel.MAX_VERSUCHE, Status.LAEUFT, null), dienst.stand(id));
}
@Test
@DisplayName("Raten über den Dienst")
void raten() {
SpielDienst dienst = dienst();
String id = dienst.neuesSpiel();
assertEquals(new Bewertung("ADIEU", "---+?"), dienst.rate(id, "adieu"));
dienst.rate(id, "FEUER");
assertEquals(new SpielStand(2, Spiel.MAX_VERSUCHE, Status.GEWONNEN, "FEUER"), dienst.stand(id));
}
@Test
@DisplayName("Die Spiele laufen unabhängig voneinander, mit den Wörtern der Wortquelle")
void unabhaengigeSpiele() {
SpielDienst dienst = dienst();
String erstes = dienst.neuesSpiel();
String zweites = dienst.neuesSpiel();
dienst.rate(erstes, "FEUER");
dienst.rate(zweites, "BLAUE");
assertEquals(Status.GEWONNEN, dienst.stand(erstes).status());
assertEquals(Status.GEWONNEN, dienst.stand(zweites).status());
}
@Test
@DisplayName("Eine unbekannte Spiel-ID wird abgelehnt")
void unbekannteId() {
SpielDienst dienst = dienst();
assertThrows(IllegalArgumentException.class, () -> dienst.stand("gibt-es-nicht"));
assertThrows(IllegalArgumentException.class, () -> dienst.rate("gibt-es-nicht", "FEUER"));
}
@Test
@DisplayName("Die feste Wortquelle liefert ihre Wörter reihum")
void festeWortquelle() {
Wortquelle quelle = new FesteWortquelle(new String[] {"FEUER", "BLAUE"});
assertEquals("FEUER", quelle.naechstesWort());
assertEquals("BLAUE", quelle.naechstesWort());
assertEquals("FEUER", quelle.naechstesWort());
}
@Test
@DisplayName("Die Auflösung bleibt geheim, solange das Spiel läuft")
void aufloesungGeheim() {
SpielDienst dienst = dienst();
String id = dienst.neuesSpiel();
dienst.rate(id, "ADIEU");
assertNull(dienst.stand(id).aufloesung());
}
@Test
@DisplayName("Die Zufalls-Wortquelle liefert nur Wörter aus ihrer Liste")
void zufallsWortquelle() {
String[] woerter = {"FEUER", "BLAUE", "KANNE"};
Wortquelle quelle = new ZufallsWortquelle(woerter);
for (int i = 0; i < 100; i++) {
String wort = quelle.naechstesWort();
assertTrue(wort.equals("FEUER") || wort.equals("BLAUE") || wort.equals("KANNE"));
}
}
}

Der letzte Test in LokalerSpielDienstTest gehört zur Übung 1 – lass ihn weg, bis du dort angekommen bist.

Wo im Spiel wird geprüft?

Am Anfang von rate – nach der Prüfung, ob das Spiel noch läuft, aber bevor gezählt oder bewertet wird. Eine private Hilfsmethode pruefeVersuch kann die bereinigte Eingabe zurückgeben oder eine Exception auslösen.

Wie liefert die feste Wortquelle reihum?

Ein Zähler merkt sich, welches Wort als Nächstes dran ist. Nach dem letzten geht es wieder von vorne los: naechstes = (naechstes + 1) % woerter.length;

Wie entsteht der SpielStand?

stand holt das Spiel aus der Map und baut daraus einen neuen SpielStand. Für die Auflösung: Läuft das Spiel noch, null – sonst getAufloesung(). Ein Bedingungsoperator passt hier gut.

Lösung
Spiel.java
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.");
}
String wort = pruefeVersuch(versuch);
Bewertung bewertung = new Bewertung(wort, Wordle.bewerte(wort, loesung));
anzahlVersuche++;
if (bewertung.istGeloest()) {
status = Status.GEWONNEN;
} else if (anzahlVersuche == MAX_VERSUCHE) {
status = Status.VERLOREN;
}
return bewertung;
}
private static String pruefeVersuch(String versuch) {
if (versuch == null) {
throw new IllegalArgumentException("Bitte ein Wort eingeben.");
}
String wort = versuch.strip().toUpperCase();
if (wort.length() != WORTLAENGE) {
throw new IllegalArgumentException("Bitte genau " + WORTLAENGE + " Buchstaben eingeben.");
}
for (int i = 0; i < wort.length(); i++) {
if (!Character.isLetter(wort.charAt(i))) {
throw new IllegalArgumentException("Bitte nur Buchstaben eingeben.");
}
}
return wort;
}
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;
}
}
Lösung
FesteWortquelle.java
package de.drv.wordle;
public class FesteWortquelle implements Wortquelle {
private final String[] woerter;
private int naechstes;
public FesteWortquelle(String[] woerter) {
if (woerter == null || woerter.length == 0) {
throw new IllegalArgumentException("Es wird mindestens ein Wort gebraucht.");
}
this.woerter = woerter.clone();
this.naechstes = 0;
}
@Override
public String naechstesWort() {
String wort = woerter[naechstes];
naechstes = (naechstes + 1) % woerter.length;
return wort;
}
}
Lösung

Die private Methode spiel(…) sucht das Spiel und meldet eine unbekannte ID. rate und stand benutzen sie beide – die Prüfung steht nur einmal da.

LokalerSpielDienst.java
package de.drv.wordle;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class LokalerSpielDienst implements SpielDienst {
private final Wortquelle wortquelle;
private final Map<String, Spiel> spiele = new HashMap<>();
public LokalerSpielDienst(Wortquelle wortquelle) {
if (wortquelle == null) {
throw new IllegalArgumentException("Ohne Wortquelle kein Spiel.");
}
this.wortquelle = wortquelle;
}
@Override
public String neuesSpiel() {
String id = UUID.randomUUID().toString();
spiele.put(id, new Spiel(wortquelle.naechstesWort()));
return id;
}
@Override
public Bewertung rate(String spielId, String versuch) {
return spiel(spielId).rate(versuch);
}
@Override
public SpielStand stand(String spielId) {
Spiel spiel = spiel(spielId);
String aufloesung = spiel.getStatus() == Status.LAEUFT ? null : spiel.getAufloesung();
return new SpielStand(spiel.getAnzahlVersuche(), Spiel.MAX_VERSUCHE, spiel.getStatus(), aufloesung);
}
private Spiel spiel(String spielId) {
Spiel spiel = spiele.get(spielId);
if (spiel == null) {
throw new IllegalArgumentException("Unbekanntes Spiel: " + spielId);
}
return spiel;
}
}
Lösung

Die Konsole kennt jetzt nur noch SpielDienst, SpielStand, Bewertung, Status und Feld – aber weder Spiel noch das gesuchte Wort. Nach einem Spiel fragt sie, ob noch eins gespielt werden soll; das nächste bekommt das nächste Wort aus der Wortquelle.

WordleKonsole.java
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";
private final SpielDienst dienst;
private final Scanner scanner;
public WordleKonsole(SpielDienst dienst, Scanner scanner) {
this.dienst = dienst;
this.scanner = scanner;
}
public void spielen() {
boolean nochmal = true;
while (nochmal) {
einSpiel();
System.out.print("Noch ein Spiel? (j/n) ");
nochmal = scanner.nextLine().strip().equalsIgnoreCase("j");
}
}
private void einSpiel() {
String id = dienst.neuesSpiel();
SpielStand stand = dienst.stand(id);
System.out.println();
System.out.println("WORDLE – errate das Wort mit 5 Buchstaben.");
while (stand.status() == Status.LAEUFT) {
System.out.print("Versuch " + (stand.versuche() + 1) + "/" + stand.maxVersuche() + ": ");
String eingabe = scanner.nextLine();
try {
Bewertung bewertung = dienst.rate(id, eingabe);
System.out.println(" " + farbig(bewertung));
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
stand = dienst.stand(id);
}
String meldung = switch (stand.status()) {
case GEWONNEN -> "Gelöst mit " + stand.versuche() + " Versuch(en)!";
case VERLOREN -> "Leider nicht geschafft. Gesucht war: " + stand.aufloesung();
case LAEUFT -> "Das Spiel läuft noch.";
};
System.out.println(meldung);
}
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();
}
}
  1. Zufallswort: Schreibe eine ZufallsWortquelle, die bei jedem Aufruf ein zufälliges Wort aus ihrer Liste liefert. Was musst du ändern, damit das Spiel sie benutzt?

    Lösung

    Zum Benutzen ändert sich nur eine Zeile in WordleStart: new ZufallsWortquelle(…) statt new FesteWortquelle(…). Weder der Dienst noch die Konsole merken etwas davon.

    ZufallsWortquelle.java
    package de.drv.wordle;
    import java.util.Random;
    public class ZufallsWortquelle implements Wortquelle {
    private final String[] woerter;
    private final Random zufall = new Random();
    public ZufallsWortquelle(String[] woerter) {
    if (woerter == null || woerter.length == 0) {
    throw new IllegalArgumentException("Es wird mindestens ein Wort gebraucht.");
    }
    this.woerter = woerter.clone();
    }
    @Override
    public String naechstesWort() {
    return woerter[zufall.nextInt(woerter.length)];
    }
    }
  2. Statistik: Lass die Konsole mitzählen, wie viele Spiele gewonnen und verloren wurden, und gib das am Ende aus.

  3. Starte zwei Spiele über denselben Dienst und rate abwechselnd in beiden. Warum kommen sie sich nicht in die Quere?

    Lösung

    Jedes Spiel ist ein eigenes Spiel-Objekt mit eigenem Zähler und eigenem Status. Der Dienst findet es über die ID. Dass ein Dienst viele Spiele gleichzeitig führen kann, wird noch wichtig werden.