Zahlenraten 3: Ein Spielleiter und eine Konsole
Wir haben die Typen und ein getestetes Spiel. Jetzt wird daraus wieder ein
Programm, das man spielen kann – dasselbe Spiel wie in Teil 1. Nur ist es diesmal
aus Teilen gebaut, die man einzeln austauschen kann.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einen Vertrag mit einer eigenen Klasse erfüllen
- Ein- und Ausgabe von den Regeln eines Programms trennen
- erklären, warum nur eine Klasse eine Implementierung beim Namen nennt
Demo-Code: zahlenraten-3
⤓ zahlenraten-3.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner zahlenraten-3 wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.
Enthält: pom.xml, Hinweis.java, Spielstart.java, Antwort.java, Spielleiter.java, Spiel.java, LokalerSpielleiter.java, Konsole.java, Start.java, SpielTest.java
Der Starter enthält die Lösung von Teil 2 und die drei neuen Klassen aus diesem Kapitel.
Drei Aufgaben, drei Klassen
Abschnitt betitelt „Drei Aufgaben, drei Klassen“Start ── erzeugt ──▶ Konsole ── kennt nur ──▶ Spielleiter (Interface) │ ▲ │ │ implements └──────── erzeugt ──────────▶ LokalerSpielleiter │ verwaltet ▼ Spiel, Spiel, …| Klasse | Aufgabe | weiß nichts von |
|---|---|---|
LokalerSpielleiter |
verwaltet die Spiele, beurteilt Versuche | der Konsole |
Konsole |
liest Eingaben, zeigt Hinweise | wo die Zahl herkommt |
Start |
steckt alles zusammen | – das ist ihre einzige Aufgabe |
Der lokale Spielleiter
Abschnitt betitelt „Der lokale Spielleiter“package de.drv.zahlenraten;
import java.util.HashMap;import java.util.Map;import java.util.UUID;
/** * Ein Spielleiter im selben Programm: Er verwaltet beliebig viele Spiele, jedes unter seiner ID. */public class LokalerSpielleiter implements Spielleiter {
private final Map<String, Spiel> spiele = new HashMap<>();
@Override public Spielstart neuesSpiel() { String id = UUID.randomUUID().toString(); // eine weltweit eindeutige Kennung spiele.put(id, Spiel.zufaellig()); return new Spielstart(id, Spiel.VON, Spiel.BIS); }
@Override public Antwort rate(String spielId, int zahl) { Spiel spiel = spiele.get(spielId); if (spiel == null) { throw new IllegalArgumentException("Kein Spiel mit der ID " + spielId); } Hinweis hinweis = spiel.rate(zahl); // wirft selbst bei ungültiger Zahl oder nach dem Ende return new Antwort(hinweis, spiel.getVersuche()); }
}- Jedes Spiel bekommt eine ID, unter der es in einer
Mapliegt.UUID.randomUUID()liefert eine Kennung wie3f2b8c1e-6a7d-4e0f-9b2a-5c8d1e7f4a60– so zufällig, dass es keine zweite gleiche gibt. ratesucht das Spiel, lässt es den Versuch beurteilen und baut daraus eineAntwort. Die Regeln selbst stehen imSpiel– der Spielleiter delegiert.- Eine unbekannte ID führt zur
IllegalArgumentException, genau wie es der Vertrag verlangt. Ungültige Zahlen und Versuche nach dem Ende meldet schon dasSpiel– der Spielleiter reicht die Exception einfach weiter.
Die Konsole
Abschnitt betitelt „Die Konsole“package de.drv.zahlenraten;
import java.util.Scanner;
/** * Das Spiel auf der Konsole. Sie kennt nur das Interface {@link Spielleiter} – wer die Zahl * kennt und wo er sitzt, weiß sie nicht. */public class Konsole {
private final Spielleiter spielleiter; private final Scanner scanner;
public Konsole(Spielleiter spielleiter, Scanner scanner) { this.spielleiter = spielleiter; this.scanner = scanner; }
/** Spielt ein Spiel bis zur richtigen Zahl. */ public void spiele() { Spielstart start = spielleiter.neuesSpiel(); System.out.println("Ich denke mir eine Zahl von " + start.von() + " bis " + start.bis() + ". Rate!");
while (true) { System.out.print("Dein Tipp: "); int zahl = Integer.parseInt(scanner.nextLine().trim()); Antwort antwort = spielleiter.rate(start.id(), zahl);
switch (antwort.hinweis()) { case ZU_KLEIN -> System.out.println("Zu klein."); case ZU_GROSS -> System.out.println("Zu groß."); case RICHTIG -> { System.out.println("Richtig! Du hast " + antwort.versuche() + " Versuche gebraucht."); return; } } } }
}- Im Konstruktor bekommt die Konsole einen
Spielleiter– keinLokalerSpielleiter. Sie kann mit jedem spielen, der den Vertrag erfüllt. - Den
Scannerbekommt sie ebenfalls von außen. Wer ihn erzeugt, schließt ihn auch wieder. - Die drei Hinweise unterscheidet ein
switchmit Pfeilen – bei einem Enum prüft der Compiler sogar, ob kein Fall fehlt. - Den Bereich kennt die Konsole nicht selbst: Sie liest ihn aus dem
Spielstart.
Zusammenstecken
Abschnitt betitelt „Zusammenstecken“package de.drv.zahlenraten;
import java.util.Scanner;
/** * Hier wird das Programm zusammengesteckt: Welcher Spielleiter, welche Konsole. Nur diese Klasse * nennt eine Implementierung beim Namen. */public class Start {
public static void main(String[] args) { Spielleiter spielleiter = new LokalerSpielleiter(); try (Scanner scanner = new Scanner(System.in)) { new Konsole(spielleiter, scanner).spiele(); } }
}Start ist die einzige Klasse, die LokalerSpielleiter beim Namen nennt.
Soll das Spiel später über das Netz laufen, ändert sich genau diese eine Zeile –
die Konsole bleibt, wie sie ist.
Ordnersrc
Ordnermain
Ordnerjava
Ordnerde
Ordnerdrv
Ordnerzahlenraten
- Hinweis.java Enum
- Spielstart.java Record
- Antwort.java Record
- Spielleiter.java Interface – der Vertrag
- Spiel.java der fachliche Kern
- LokalerSpielleiter.java erfüllt den Vertrag
- Konsole.java Ein- und Ausgabe
- Start.java steckt zusammen
Ordnertest
Ordnerjava
Ordnerde
Ordnerdrv
Ordnerzahlenraten
- SpielTest.java
Übung: Die Konsole wird robust
Abschnitt betitelt „Übung: Die Konsole wird robust“Arbeite im Demo-Projekt zahlenraten-3.
-
Falsche Eingaben: Wer
fünfzigoder500eintippt, bekommt im Moment einen Absturz. Fange dieNumberFormatExceptionab – und dieIllegalArgumentException, die der Spielleiter bei einer Zahl außerhalb des Bereichs wirft. Gib dann die Meldung der Exception aus: Sie kommt vom Spielleiter, die Konsole muss die Regel gar nicht selbst kennen. -
Mehrere Runden: Nach jedem Spiel fragt die Konsole Noch eine Runde? (j/n) und beginnt mit
neuesSpiel()ein neues. -
Tests für den Spielleiter: Schreibe eine Testklasse
LokalerSpielleiterTest. Weil die geheime Zahl zufällig ist, rät dein Test mit Halbieren: immer die Mitte des noch möglichen Bereichs, bisRICHTIGkommt. Prüfe damit, dass jede Zahl in höchstens sieben Versuchen gefunden wird. Und: Zwei Spiele haben verschiedene IDs, eine unbekannte ID wird abgelehnt, nachRICHTIGgibt es keine weiteren Versuche. -
Für Schnelle: Ein
GemeinerSpielleiter, der schummelt: Er legt sich nie auf eine Zahl fest. Er merkt sich nur, welcher Bereich nach seinen bisherigen Antworten noch möglich ist, und antwortet immer so, dass möglichst viel übrig bleibt. Richtig sagt er erst, wenn nur noch eine Zahl passt. Starte die Konsole mit ihm – ohne an der Konsole etwas zu ändern. Hält er auch gegen Halbieren durch?
Lösung
Ich denke mir eine Zahl von 1 bis 100. Rate!Dein Tipp: abcBitte eine Zahl eingeben.Dein Tipp: 0Nur Zahlen von 1 bis 100: 0Dein Tipp: 50Zu klein.Die beiden catch-Blöcke stehen in dieser Reihenfolge, weil
NumberFormatException eine Unterklasse von IllegalArgumentException ist. Die
Meldung Nur Zahlen von 1 bis 100 steht im Spiel – die Konsole gibt sie nur
weiter.
package de.drv.zahlenraten;
import java.util.Scanner;
/** * Das Spiel auf der Konsole – Stufen 1 und 2: falsche Eingaben abfangen, mehrere Runden. * Sie kennt weiterhin nur das Interface {@link Spielleiter}. */public class Konsole {
private final Spielleiter spielleiter; private final Scanner scanner;
public Konsole(Spielleiter spielleiter, Scanner scanner) { this.spielleiter = spielleiter; this.scanner = scanner; }
/** Spielt Runden, bis der Spieler aufhören möchte. */ public void spiele() { do { spieleRunde(); System.out.print("Noch eine Runde? (j/n) "); } while (scanner.nextLine().trim().equalsIgnoreCase("j")); }
private void spieleRunde() { Spielstart start = spielleiter.neuesSpiel(); System.out.println("Ich denke mir eine Zahl von " + start.von() + " bis " + start.bis() + ". Rate!");
while (true) { System.out.print("Dein Tipp: "); Antwort antwort; try { int zahl = Integer.parseInt(scanner.nextLine().trim()); antwort = spielleiter.rate(start.id(), zahl); } catch (NumberFormatException e) { System.out.println("Bitte eine Zahl eingeben."); continue; } catch (IllegalArgumentException e) { System.out.println(e.getMessage()); // die Meldung kommt vom Spielleiter continue; }
switch (antwort.hinweis()) { case ZU_KLEIN -> System.out.println("Zu klein."); case ZU_GROSS -> System.out.println("Zu groß."); case RICHTIG -> { System.out.println("Richtig! Du hast " + antwort.versuche() + " Versuche gebraucht."); return; } } } }
}Lösung
halbiere ist eine Hilfsmethode, die ein ganzes Spiel durchspielt – für jeden
Spielleiter. Deshalb prüft der letzte Test mit ihr auch den gemeinen.
package de.drv.zahlenraten;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotEquals;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 LokalerSpielleiterTest {
/** Rät durch Halbieren, bis RICHTIG kommt, und liefert die letzte Antwort. */ static Antwort halbiere(Spielleiter spielleiter, Spielstart start) { int von = start.von(); int bis = start.bis(); while (true) { int mitte = (von + bis) / 2; Antwort antwort = spielleiter.rate(start.id(), mitte); switch (antwort.hinweis()) { case ZU_KLEIN -> von = mitte + 1; case ZU_GROSS -> bis = mitte - 1; case RICHTIG -> { return antwort; } } } }
@Test @DisplayName("Ein neues Spiel geht von 1 bis 100 und hat eine ID") void neuesSpiel() { Spielstart start = new LokalerSpielleiter().neuesSpiel(); assertEquals(1, start.von()); assertEquals(100, start.bis()); assertTrue(start.id() != null && !start.id().isBlank()); }
@Test @DisplayName("Durch Halbieren findet man jede Zahl in höchstens 7 Versuchen") void halbieren() { LokalerSpielleiter spielleiter = new LokalerSpielleiter(); for (int i = 0; i < 200; i++) { Antwort antwort = halbiere(spielleiter, spielleiter.neuesSpiel()); assertEquals(Hinweis.RICHTIG, antwort.hinweis()); assertTrue(antwort.versuche() <= 7, "Versuche: " + antwort.versuche()); } }
@Test @DisplayName("Zwei Spiele haben verschiedene IDs und zählen getrennt") void zweiSpiele() { LokalerSpielleiter spielleiter = new LokalerSpielleiter(); Spielstart erstes = spielleiter.neuesSpiel(); Spielstart zweites = spielleiter.neuesSpiel(); assertNotEquals(erstes.id(), zweites.id()); halbiere(spielleiter, erstes); // Das erste Spiel ist vorbei – das zweite beginnt trotzdem bei seinem ersten Versuch assertEquals(1, spielleiter.rate(zweites.id(), 50).versuche()); }
@Test @DisplayName("Eine unbekannte ID wird abgelehnt") void unbekannteId() { assertThrows(IllegalArgumentException.class, () -> new LokalerSpielleiter().rate("gibt-es-nicht", 50)); }
@Test @DisplayName("Nach RICHTIG nimmt der Spielleiter keinen Versuch mehr an") void nachDemEnde() { LokalerSpielleiter spielleiter = new LokalerSpielleiter(); Spielstart start = spielleiter.neuesSpiel(); halbiere(spielleiter, start); assertThrows(IllegalStateException.class, () -> spielleiter.rate(start.id(), 50)); }
@Test @DisplayName("Auch der gemeine Spielleiter verliert gegen Halbieren – nach höchstens 7 Versuchen") void gemein() { GemeinerSpielleiter spielleiter = new GemeinerSpielleiter(); Antwort antwort = halbiere(spielleiter, spielleiter.neuesSpiel()); assertEquals(Hinweis.RICHTIG, antwort.hinweis()); assertTrue(antwort.versuche() <= 7, "Versuche: " + antwort.versuche()); }
}Lösung
package de.drv.zahlenraten;
import java.util.Scanner;
/** * Hier wird das Programm zusammengesteckt. Mit dem Argument {@code gemein} spielt man gegen den * schummelnden Spielleiter – die Konsole bleibt dieselbe. */public class Start {
public static void main(String[] args) { Spielleiter spielleiter = args.length > 0 && args[0].equals("gemein") ? new GemeinerSpielleiter() : new LokalerSpielleiter(); try (Scanner scanner = new Scanner(System.in)) { new Konsole(spielleiter, scanner).spiele(); } }
}Gestartet mit dem Argument gemein, gegen Halbieren:
Ich denke mir eine Zahl von 1 bis 100. Rate!Dein Tipp: 50Zu klein.Dein Tipp: 75Zu klein.Dein Tipp: 88Zu klein.Dein Tipp: 94Zu klein.Dein Tipp: 97Zu klein.Dein Tipp: 99Zu klein.Dein Tipp: 100Richtig! Du hast 7 Versuche gebraucht.Er hält nicht durch: Auch der gemeinste Spielleiter kann den möglichen Bereich
nur so lange offen halten, bis er auf eine Zahl geschrumpft ist – und Halbieren
schafft das bei 100 Zahlen immer in sieben Schritten. Die Konsole hat von all dem
nichts gemerkt: Sie kennt nur den Spielleiter.
Der Stand ist eine statische geschachtelte Klasse (siehe
Innere Klassen): Sie gehört nur zu diesem
Spielleiter und braucht keine eigene Datei.
package de.drv.zahlenraten;
import java.util.HashMap;import java.util.Map;import java.util.UUID;
/** * Stufe 4: Ein Spielleiter, der schummelt – er legt sich nie auf eine Zahl fest. Er merkt sich * nur, welcher Bereich nach seinen bisherigen Antworten noch möglich ist, und antwortet so, * dass möglichst viel übrig bleibt. Richtig ist ein Versuch erst, wenn nur noch eine Zahl passt. * * <p>Weil er den Vertrag {@link Spielleiter} erfüllt, spielt die Konsole mit ihm, ohne es zu merken. */public class GemeinerSpielleiter implements Spielleiter {
/** Der noch mögliche Bereich eines Spiels und die Zahl der Versuche. */ private static class Stand { int von = Spiel.VON; int bis = Spiel.BIS; int versuche; boolean vorbei; }
private final Map<String, Stand> spiele = new HashMap<>();
@Override public Spielstart neuesSpiel() { String id = UUID.randomUUID().toString(); spiele.put(id, new Stand()); return new Spielstart(id, Spiel.VON, Spiel.BIS); }
@Override public Antwort rate(String spielId, int zahl) { Stand stand = spiele.get(spielId); if (stand == null) { throw new IllegalArgumentException("Kein Spiel mit der ID " + spielId); } if (stand.vorbei) { throw new IllegalStateException("Das Spiel ist schon vorbei."); } if (zahl < Spiel.VON || zahl > Spiel.BIS) { throw new IllegalArgumentException("Nur Zahlen von " + Spiel.VON + " bis " + Spiel.BIS + ": " + zahl); } stand.versuche++;
int darueber = zahl < stand.bis ? stand.bis - Math.max(zahl, stand.von - 1) : 0; // Zahlen > zahl int darunter = zahl > stand.von ? Math.min(zahl, stand.bis + 1) - stand.von : 0; // Zahlen < zahl
if (darueber == 0 && darunter == 0) { // nur noch zahl selbst ist möglich stand.vorbei = true; return new Antwort(Hinweis.RICHTIG, stand.versuche); } if (darueber >= darunter) { stand.von = Math.max(stand.von, zahl + 1); return new Antwort(Hinweis.ZU_KLEIN, stand.versuche); } stand.bis = Math.min(stand.bis, zahl - 1); return new Antwort(Hinweis.ZU_GROSS, stand.versuche); }
}