Zum Inhalt springen

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.

  • 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 herunterladen

Der 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.

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
LokalerSpielleiter.java
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 Map liegt. UUID.randomUUID() liefert eine Kennung wie 3f2b8c1e-6a7d-4e0f-9b2a-5c8d1e7f4a60 – so zufällig, dass es keine zweite gleiche gibt.
  • rate sucht das Spiel, lässt es den Versuch beurteilen und baut daraus eine Antwort. Die Regeln selbst stehen im Spiel – 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 das Spiel – der Spielleiter reicht die Exception einfach weiter.
Konsole.java
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 – kein LokalerSpielleiter. Sie kann mit jedem spielen, der den Vertrag erfüllt.
  • Den Scanner bekommt sie ebenfalls von außen. Wer ihn erzeugt, schließt ihn auch wieder.
  • Die drei Hinweise unterscheidet ein switch mit 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.
Start.java
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

Arbeite im Demo-Projekt zahlenraten-3.

  1. Falsche Eingaben: Wer fünfzig oder 500 eintippt, bekommt im Moment einen Absturz. Fange die NumberFormatException ab – und die IllegalArgumentException, 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.

  2. Mehrere Runden: Nach jedem Spiel fragt die Konsole Noch eine Runde? (j/n) und beginnt mit neuesSpiel() ein neues.

  3. 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, bis RICHTIG kommt. Prüfe damit, dass jede Zahl in höchstens sieben Versuchen gefunden wird. Und: Zwei Spiele haben verschiedene IDs, eine unbekannte ID wird abgelehnt, nach RICHTIG gibt es keine weiteren Versuche.

  4. 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
Terminal-Fenster
Ich denke mir eine Zahl von 1 bis 100. Rate!
Dein Tipp: abc
Bitte eine Zahl eingeben.
Dein Tipp: 0
Nur Zahlen von 1 bis 100: 0
Dein Tipp: 50
Zu 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.

Konsole.java
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.

LokalerSpielleiterTest.java
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
Start.java
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:

Terminal-Fenster
Ich denke mir eine Zahl von 1 bis 100. Rate!
Dein Tipp: 50
Zu klein.
Dein Tipp: 75
Zu klein.
Dein Tipp: 88
Zu klein.
Dein Tipp: 94
Zu klein.
Dein Tipp: 97
Zu klein.
Dein Tipp: 99
Zu klein.
Dein Tipp: 100
Richtig! 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.

GemeinerSpielleiter.java
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);
}
}