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?
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- 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 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-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
Die Begriffe des Spiels
Abschnitt betitelt „Die Begriffe des Spiels“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.
Warum der Spielleiter ein Interface ist
Abschnitt betitelt „Warum der Spielleiter ein Interface ist“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.
Die Typen
Abschnitt betitelt „Die Typen“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}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) {}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) {}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. ratebekommt die Spiel-ID. Ein Spielleiter kann mehrere Spiele gleichzeitig leiten – so wie später ein Server für viele Spieler.
Die Klasse Spiel
Abschnitt betitelt „Die Klasse Spiel“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:
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.
Übung: Das Spiel gegen die Tests
Abschnitt betitelt „Übung: Das Spiel gegen die Tests“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
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:
-
Raten und zählen: Die geheime Zahl wird gespeichert,
rateliefert den richtigenHinweisund zählt mit, nachRICHTIGist das Spiel vorbei.zufaellig()erzeugt ein Spiel mit einer Zahl vonVONbisBIS. -
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. -
Nach dem Ende: Nach
RICHTIGwirftrateeineIllegalStateException. -
Für Schnelle: Schreibe zwei eigene Tests dazu – zum Beispiel, dass auf
ZU_KLEINmit einer größeren Zahl auch einmalZU_GROSSfolgen kann, oder dasszufaellig()bei vielen Spielen nicht immer dieselbe Zahl liefert. Wie testet man das, ohne die geheime Zahl zu kennen?
Lösung
pruefeBereichwird an zwei Stellen gebraucht – im Konstruktor und inrate. Als eigeneprivate staticMethode steht die Regel nur einmal da.- In
ratekommt die Prüfung vorversuche++. So zählt ein ungültiger Versuch nicht. ThreadLocalRandom.current()liefert einen Zufallsgenerator, ohne dass man selbst einRandom-Objekt aufbewahren muss.geheimeZahlistfinal– sie ändert sich nie.versucheundvorbeiändern sich, aber nur überrate. 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.
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); } }
}