Zum Inhalt springen

Zahlenraten 2: In Typen denken

Das Spiel aus Teil 1 läuft. Aber alles steckt in main: die Regeln, das Zählen, die Ein- und Ausgabe. Wollten wir das Spiel testen, über das Netz spielen oder eine Webseite davorsetzen, müssten wir alles neu schreiben. Bevor wir weiterbauen, halten wir deshalb an und fragen: Aus welchen Teilen besteht dieses Spiel eigentlich?

  • aus einer Beschreibung die Begriffe herausfinden, die ein Programm braucht
  • für jeden Begriff begründet die passende Art von Typ wählen: Enum, Record, Klasse oder Interface
  • eine Klasse so schreiben, dass vorgegebene Tests grün werden

Demo-Code: zahlenraten-2

⤓ zahlenraten-2.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-2 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, SpielTest.java

Wie im Kapitel Denken in Objekten beginnen wir mit einer Beschreibung:

Ein Spielleiter denkt sich eine geheime Zahl von 1 bis 100. Der Spieler beginnt ein Spiel und gibt Versuche ab. Auf jeden Versuch antwortet der Spielleiter mit einem Hinweis: zu klein, zu groß oder richtig. Er sagt auch, wie viele Versuche es bisher waren. Ist die Zahl geraten, ist das Spiel vorbei.

Daraus werden fünf Typen – und jeder ist mit Absicht eine andere Art von Typ:

Begriff Typ Art warum diese Art?
Hinweis Hinweis Enum Es gibt genau drei mögliche Werte, und es kommen keine hinzu.
Start eines Spiels Spielstart Record Nur Daten, die sich nicht ändern: ID und Bereich.
Antwort auf einen Versuch Antwort Record Ebenso: Hinweis und Zahl der Versuche – ein Wert, der weitergegeben wird.
ein Spiel Spiel Klasse Es hat einen Zustand, der sich ändert (die Versuche, „vorbei“), und Verhalten, das diesen Zustand schützt.
Spielleiter Spielleiter Interface Eine Rolle, kein bestimmtes Ding. Wer die Zahl kennt, kann vieles sein – siehe unten.

Die geheime Zahl und die Versuche werden keine eigenen Typen: Sie sind einfache Werte, die zum Spiel gehören – Felder.

Wer könnte die geheime Zahl kennen?

  • ein Objekt im selben Programm – das bauen wir in Teil 3,
  • ein Server im Netz – später,
  • ein Spielleiter, der schummelt,
  • in einem Test: einer, dessen Zahl wir vorher festlegen.

Für den Spieler ist das alles gleich: Er beginnt ein Spiel und gibt Versuche ab. Genau das beschreibt das Interface – den Vertrag aus dem Kapitel Verträge. Wir legen ihn jetzt fest, obwohl es noch keine einzige Implementierung gibt. So kann alles, was später kommt, sich auf ihn verlassen.

Hinweis.java
package de.drv.zahlenraten;
/**
* Was der Spielleiter zu einem Versuch sagt. Es gibt genau drei Antworten – deshalb ein Enum.
*
* <p>{@code ZU_KLEIN} heißt: <em>der Versuch</em> war zu klein, die gesuchte Zahl ist größer.
*/
public enum Hinweis {
ZU_KLEIN,
ZU_GROSS,
RICHTIG
}
Spielstart.java
package de.drv.zahlenraten;
/**
* Was man beim Start eines Spiels erfährt: unter welcher ID es läuft und in welchem Bereich
* die Zahl liegt. Nur Daten, die sich nicht ändern – deshalb ein Record.
*/
public record Spielstart(String id, int von, int bis) {
}
Antwort.java
package de.drv.zahlenraten;
/**
* Die Antwort auf einen Versuch: der Hinweis und wie viele Versuche es bisher waren.
*/
public record Antwort(Hinweis hinweis, int versuche) {
}
Spielleiter.java
package de.drv.zahlenraten;
/**
* Wer die geheime Zahl kennt und die Versuche beurteilt – der Vertrag zwischen dem, der spielt,
* und dem, der die Zahl kennt.
*
* <p>Wer spielt (zum Beispiel die Konsole), kennt nur dieses Interface. Ob der Spielleiter im
* selben Programm sitzt oder auf einem Server im Netz, merkt er nicht.
*/
public interface Spielleiter {
/** Beginnt ein neues Spiel mit einer neuen geheimen Zahl. */
Spielstart neuesSpiel();
/**
* Beurteilt einen Versuch in einem laufenden Spiel.
*
* @throws IllegalArgumentException wenn es kein Spiel mit dieser ID gibt
* oder die Zahl außerhalb des Bereichs liegt
* @throws IllegalStateException wenn das Spiel schon vorbei ist
*/
Antwort rate(String spielId, int zahl);
}
  • Im Javadoc des Spielleiters steht nicht nur, was die Methoden tun, sondern auch, wann sie eine Exception werfen. Das gehört zum Vertrag: Jede Implementierung muss sich genauso verhalten.
  • rate bekommt die Spiel-ID. Ein Spielleiter kann mehrere Spiele gleichzeitig leiten – so wie später ein Server für viele Spieler.

Das Spiel ist der fachliche Kern: Es kennt die geheime Zahl und die Regeln. Es weiß nichts von Konsole, Netz oder Spielleiter – und lässt sich deshalb gut testen. Im Demo-Code ist es noch ein Gerüst:

Spiel.java
package de.drv.zahlenraten;
/**
* Ein einzelnes Spiel: kennt die geheime Zahl und zählt die Versuche.
*
* <p>Übung: Die Methoden sind noch Platzhalter. Mach die Tests in {@code SpielTest} grün.
*/
public class Spiel {
public static final int VON = 1;
public static final int BIS = 100;
/** Ein Spiel mit einer bekannten Zahl – praktisch für Tests. */
public Spiel(int geheimeZahl) {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
/** Ein Spiel mit einer zufälligen Zahl von VON bis BIS. */
public static Spiel zufaellig() {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
/** Beurteilt einen Versuch und zählt ihn mit. */
public Hinweis rate(int zahl) {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
/** Wie viele gültige Versuche es bisher gab. */
public int getVersuche() {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
/** Ob die Zahl schon geraten wurde. */
public boolean istVorbei() {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
}

Zwei Wege, ein Spiel zu erzeugen:

  • new Spiel(37) mit einer bekannten Zahl – für Tests. Ein Test mit einer Zufallszahl wüsste ja nicht, was herauskommen soll.
  • Spiel.zufaellig() – eine statische Fabrikmethode: Sie erzeugt ein Spiel mit einer Zufallszahl. Ihr Name sagt, was sie tut – deutlicher als ein zweiter Konstruktor.

Im Demo-Projekt liegt unter src\test\java die Testklasse SpielTest. Sie beschreibt genau, wie sich ein Spiel verhalten soll. Starte sie: Alle acht Tests sind rot – die Methoden werfen noch eine UnsupportedOperationException.

SpielTest.java
SpielTest.java
package de.drv.zahlenraten;
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 SpielTest {
// ----- Stufe 1: raten und zählen ----------------------------------------------------
@Test
@DisplayName("Stufe 1: Ein zu kleiner Versuch ergibt ZU_KLEIN, ein zu großer ZU_GROSS")
void hinweise() {
Spiel spiel = new Spiel(37);
assertEquals(Hinweis.ZU_KLEIN, spiel.rate(20));
assertEquals(Hinweis.ZU_GROSS, spiel.rate(50));
assertEquals(Hinweis.RICHTIG, spiel.rate(37));
}
@Test
@DisplayName("Stufe 1: Jeder Versuch wird gezählt")
void versucheZaehlen() {
Spiel spiel = new Spiel(37);
assertEquals(0, spiel.getVersuche());
spiel.rate(50);
spiel.rate(25);
assertEquals(2, spiel.getVersuche());
}
@Test
@DisplayName("Stufe 1: Erst nach RICHTIG ist das Spiel vorbei")
void vorbei() {
Spiel spiel = new Spiel(37);
assertFalse(spiel.istVorbei());
spiel.rate(50);
assertFalse(spiel.istVorbei());
spiel.rate(37);
assertTrue(spiel.istVorbei());
}
@Test
@DisplayName("Stufe 1: Ein zufälliges Spiel liegt im Bereich und ist zu Beginn nicht vorbei")
void zufaellig() {
for (int i = 0; i < 100; i++) {
Spiel spiel = Spiel.zufaellig();
assertFalse(spiel.istVorbei());
assertEquals(0, spiel.getVersuche());
// Irgendein Versuch im Bereich ist erlaubt
spiel.rate(Spiel.VON);
}
}
// ----- Stufe 2: ungültige Zahlen ----------------------------------------------------
@Test
@DisplayName("Stufe 2: Eine geheime Zahl außerhalb von 1 bis 100 ist ungültig")
void geheimeZahlAusserhalb() {
assertThrows(IllegalArgumentException.class, () -> new Spiel(0));
assertThrows(IllegalArgumentException.class, () -> new Spiel(101));
}
@Test
@DisplayName("Stufe 2: Ein Versuch außerhalb des Bereichs wird abgelehnt und nicht gezählt")
void versuchAusserhalb() {
Spiel spiel = new Spiel(37);
assertThrows(IllegalArgumentException.class, () -> spiel.rate(0));
assertThrows(IllegalArgumentException.class, () -> spiel.rate(101));
assertEquals(0, spiel.getVersuche());
}
// ----- Stufe 3: nach dem Ende -------------------------------------------------------
@Test
@DisplayName("Stufe 3: Nach RICHTIG wird kein Versuch mehr angenommen")
void nachDemEnde() {
Spiel spiel = new Spiel(37);
spiel.rate(37);
assertThrows(IllegalStateException.class, () -> spiel.rate(40));
assertEquals(1, spiel.getVersuche());
}
@Test
@DisplayName("Stufe 3: Die Grenzen 1 und 100 sind erlaubt")
void grenzen() {
assertEquals(Hinweis.RICHTIG, new Spiel(1).rate(1));
assertEquals(Hinweis.RICHTIG, new Spiel(100).rate(100));
}
}

Fülle die Klasse Spiel aus, sodass ein Test nach dem anderen grün wird. Die Tests sind nach Stufen sortiert:

  1. Raten und zählen: Die geheime Zahl wird gespeichert, rate liefert den richtigen Hinweis und zählt mit, nach RICHTIG ist das Spiel vorbei. zufaellig() erzeugt ein Spiel mit einer Zahl von VON bis BIS.

  2. Ungültige Zahlen: Eine geheime Zahl außerhalb von 1 bis 100 und ein Versuch außerhalb des Bereichs führen zu einer IllegalArgumentException. Ein ungültiger Versuch zählt nicht.

  3. Nach dem Ende: Nach RICHTIG wirft rate eine IllegalStateException.

  4. Für Schnelle: Schreibe zwei eigene Tests dazu – zum Beispiel, dass auf ZU_KLEIN mit einer größeren Zahl auch einmal ZU_GROSS folgen kann, oder dass zufaellig() bei vielen Spielen nicht immer dieselbe Zahl liefert. Wie testet man das, ohne die geheime Zahl zu kennen?

Lösung
  • pruefeBereich wird an zwei Stellen gebraucht – im Konstruktor und in rate. Als eigene private static Methode steht die Regel nur einmal da.
  • In rate kommt die Prüfung vor versuche++. So zählt ein ungültiger Versuch nicht.
  • ThreadLocalRandom.current() liefert einen Zufallsgenerator, ohne dass man selbst ein Random-Objekt aufbewahren muss.
  • geheimeZahl ist final – sie ändert sich nie. versuche und vorbei ändern sich, aber nur über rate. Von außen kann niemand schummeln.

Zu Stufe 4: Ohne die Zahl zu kennen, kann ein Test raten – zum Beispiel immer die Mitte des noch möglichen Bereichs. Das kommt im nächsten Teil.

Spiel.java
package de.drv.zahlenraten;
import java.util.concurrent.ThreadLocalRandom;
/**
* Ein einzelnes Spiel: kennt die geheime Zahl und zählt die Versuche.
*/
public class Spiel {
public static final int VON = 1;
public static final int BIS = 100;
private final int geheimeZahl;
private int versuche;
private boolean vorbei;
/** Ein Spiel mit einer bekannten Zahl – praktisch für Tests. */
public Spiel(int geheimeZahl) {
pruefeBereich(geheimeZahl);
this.geheimeZahl = geheimeZahl;
}
/** Ein Spiel mit einer zufälligen Zahl von VON bis BIS. */
public static Spiel zufaellig() {
return new Spiel(ThreadLocalRandom.current().nextInt(VON, BIS + 1));
}
/** Beurteilt einen Versuch und zählt ihn mit. */
public Hinweis rate(int zahl) {
if (vorbei) {
throw new IllegalStateException("Das Spiel ist schon vorbei.");
}
pruefeBereich(zahl); // vor dem Zählen: ein ungültiger Versuch zählt nicht
versuche++;
if (zahl < geheimeZahl) {
return Hinweis.ZU_KLEIN;
}
if (zahl > geheimeZahl) {
return Hinweis.ZU_GROSS;
}
vorbei = true;
return Hinweis.RICHTIG;
}
/** Wie viele gültige Versuche es bisher gab. */
public int getVersuche() {
return versuche;
}
/** Ob die Zahl schon geraten wurde. */
public boolean istVorbei() {
return vorbei;
}
private static void pruefeBereich(int zahl) {
if (zahl < VON || zahl > BIS) {
throw new IllegalArgumentException("Nur Zahlen von " + VON + " bis " + BIS + ": " + zahl);
}
}
}