Update of exercises

Assignment_031/readme.md

@@ -0,0 +1,25 @@
+# Deep-Copy mit `clone()`
+
+
+
+## Lernziel
+
+Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
+
+## Aufgabe
+
+Im Paket [pr2.object.clone_alien](../sources/src/main/java/pr2/object/clone_alien/) fügen Sie der Klasse `Alien` eine `clone()`-Methode hinzu, die eine _tiefe Kopie_ der Objekte anlegt. Hierzu müssen Sie auch Raumanzug mit einer `clone()`-Methode ausstatten.
+
+Testen Sie, ob Ihre Implementierung korrekt funktioniert, indem Sie die vorhandenen Testfälle ausführen. Damit die Tests laufen können, müssen Sie die Kommentarzeichen entfernen.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_032/readme.md

@@ -0,0 +1,25 @@
+# Clone
+
+
+
+## Lernziel
+
+Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
+
+## Aufgabe
+
+Im Paket [pr2.object.clone_person](../sources/src/main/java/pr2/object/clone_person) finden Sie die Klasse `Person`.
+
+Erweitern Sie die Klasse bitte um eine `clone()`-Methode, die eine tiefe Kopie (**deep copy**) durchführt.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_033/readme.md

@@ -0,0 +1,31 @@
+# `equals()` und `hashCode()` implementieren und nutzen
+
+
+
+## Lernziel
+
+Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
+
+## Aufgabe
+
+Im Projekt finden Sie ein Paket [pr2.object.equals_hashcode](../sources/src/main/java/pr2/object/equals_hashcode/) mit zwei Klassen `Wesen` und `Ork` und einen Testfall `WesenTest`.
+
+Wenn Sie den Test ausführen wird er nicht erfolgreich sein, da die Methoden `equals` und `hashCode` in der Klasse Ork fehlen.
+
+Schauen Sie sich die `equals`- und `hashCode`-Methoden in `Wesen` an und versuchen Sie die Methoden zu verstehen.
+
+Schreiben Sie im nächsten Schritt korrekte `equals`- und `hashCode`-Methoden für `Ork`. __Achtung:__ Sie sollten für Ihre Lösung die Klasse `Wesen` nicht verändern.
+
+Führen Sie den Test erneut aus, um sicherzustellen, dass die Methoden richtig funktionieren.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_034/readme.md

@@ -0,0 +1,25 @@
+# equals und hashCode
+
+
+
+## Lernziel
+
+Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
+
+## Aufgabe
+
+Im Paket [pr2.object.equals_person](../sources/src/main/java/pr2/object/equals_person) finden Sie die Klasse `Person`.
+
+Geben Sie bitte den Java-Quelltext einer `equals`- und `hashCode`-Methode für diese Klasse an, die die in der Klasse `java.lang.Object` zugesicherte Äquivalenzbeziehung einhalten.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_035/readme.md

@@ -0,0 +1,37 @@
+# `toString()`-Methode implementieren
+
+
+
+## Lernziel
+
+Klassen mit einer `toString()`-Methode versehen und diese gegenseitig nutzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.tostring](../sources/src/main/java/pr2/object/tostring/).
+
+Lassen Sie die Klasse `Ausgabe` laufen und sehen Sie sich die Ausgabe an. Versuchen Sie zu verstehen, wie es zu dieser Ausgabe kommt und was sie bedeutet.
+
+Schreiben Sie im nächsten Schritt für die Klassen `Alien` und `Raumanzug` passende `toString()`-Methoden, sodass beim Aufruf der Klasse `Ausgabe` eine sinnvolle Ausgabe entsteht. Geben Sie
+
+  * den Namen des Aliens,
+  * die Marke des Raumanzuges und
+  * den vorhandenen Sauerstoffvorrat
+
+aus.
+
+Eine beispielhafte Ausgabe könnte wie folgt aussehen:
+
+`Ich bin ein Alien und heiße 'E.T.'. Ich trage einen Raumanzug von Spaceman 2000 (Füllstand 19%).`
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_036/readme.md

@@ -0,0 +1,27 @@
+# Optimierung bei Integer
+
+
+
+## Lernziel
+
+Wrapper-Klassen und deren Optimierungen verstehen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.wrapper_boxsearch](../sources/src/main/java/pr2/object/wrapper_boxsearch/).
+
+Bei den Wrapper-Typen (z.B. `Integer`) wird eine interne Optimierung durchgeführt, die dazu führt, dass bei Werten unterhalb einer bestimmten Schranke, beim Autoboxing immer wieder dasselbe Objekt verwendet wird, anstatt ein neues Wrapper-Objekt zu erzeugten.
+
+Schreiben Sie bitte ein Programm in der Klasse `BoxSearcher`, das für `Integer` diese Schranke sucht, indem es die Werte von `0` bis `200` auf diese Eigenschaft hin untersucht und für jeden Integer-Wert ausgibt, ob der Mechanismus bei ihm greift oder nicht.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_037/readme.md

@@ -0,0 +1,38 @@
+# Methoden der Wrapper-Klassen
+
+
+
+## Lernziel
+
+Wrapper-Klassen nutzen, um Zahlen umzuwandeln.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.object.wrapper_umwandler](../sources/src/main/java/pr2/object/wrapper_umwandler/).
+
+Vervollständigen Sie die Klasse `Umwandler` so, dass die Methode `toString` eine Zahl nimmt und in vier verschiedenen Formaten ausgibt. Schauen Sie sich die Klasse `Integer` an und überlegen Sie, welche der vorhandenen statischen Methoden für das Problem passend sein könnten.
+
+Eine beispielhafte könnte wie folgt aussehen:
+
+```console
+Dezimal: 17871
+Hex    : 45cf
+Oktal  : 42717
+Binär  : 100010111001111
+```
+
+Im nächsten Schritt stellen Sie bitte die Methode `fromString` fertig. Auch hierzu sollten Sie sich die Klasse `Integer` genauer anschauen.
+
+Führen Sie das Programm aus und schauen Sie, ob das Ergebnis sinnvoll ist.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_038/readme.md

@@ -0,0 +1,35 @@
+# Eigene Enumeration schreiben und verwenden
+
+
+
+## Lernziel
+
+Eine einfache Enumeration (ohne abstrakte Methoden) erstellen und in einem kleinen Programm einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.enums.eigene](../sources/src/main/java/pr2/enums/eigene_enumeration/).
+
+In Rollenspielen verwendet man oft Würfel mit einer unterschiedlichen Anzahl von Seiten. Üblich sind 4-, 6-, 8-, 10-, und 12-seitige Würfel. Das vorliegende Programm erlaubt es unterschiedliche Würfel zu simulieren.
+
+Betrachten Sie das vorliegende Projekt. Darin gibt es eine Klasse `Wuerfel`, die einen Würfel in einem Rollenspiel simulieren kann und einen dazugehörigen Test in `WuerfelTest`. Welche Art von Würfel man haben möchte, setzt man über den Konstruktorparameter von `Wuerfel` und die entsprechenden Konstanten (z.B. `D6`). Lassen Sie die Unit-Test laufen. Wahrscheinlich wird einer fehlschlagen. Korrigieren Sie den Fehler, damit alle Tests grün sind.
+
+Das Problem mit der vorliegenden Klasse ist, dass man auch Würfel mit einer anderen Augenzahl (insbesondere ungerade) erzeugen kann. Um dies zu verhindern, sollen Sie das Programm auf die Verwendung von Enumerationen umstellen.
+
+Schreiben Sie eine Enumeration `WuerfelTyp`, die über die Konstanten `D4`, `D6`,`D8`, `D10` und `D12` die möglichen Würfelarten vorgibt. Ändern Sie den Konstruktorparameter von `Wuerfel` so, dass er anstatt eines `int` einen `WuerfelTyp` nimmt. Damit das Programm erweiterbar bleibt, speichern Sie die Anzahl der Seiten, die zu den jeweiligen Typen gehören in der Enumeration und nicht in der Klasse `Wuerfel`. Geben Sie der Enumeration außerdem eine Methode mit, welche den erwarteten Durchschnittswert für eine große Anzahl von Würfen zurückgibt (Methodenname `average`).
+
+Ändern Sie die Tests so, dass sie mit der Enumeration arbeiten. Codieren Sie die Enum-Werte (`D4`...`D12`) nicht hart im Test, sondern verwenden Sie die Methode `values()`, um die Tests möglichst generisch zu gestalten.
+
+Fügen Sie nun einen weiteren Würfeltyp `D20` ein und testen Sie diesen. Wenn Sie alles richtig gemacht haben, müssen Sie hierfür nur die Enumeration `WuerfelTyp` ändern, alle anderen Klassen bleiben unverändert.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

Assignment_039/readme.md

@@ -0,0 +1,15 @@
+# Enumeration schreiben
+
+
+
+## Lernziel
+
+Eine einfache Enumeration (ohne abstrakte Methoden) erstellen und in einem kleinen Programm einsetzen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.enums.filme](../sources/src/main/java/pr2/enums/filme/).
+
+Schreiben Sie eine Enumeration `LieblingsFilme`, die Ihre Lieblingsfilme enthalten soll. Speichern Sie zu jedem Film bitte den Titel, den Regisseur und eine Bewertung auf einer Skala von 0 bis 10. Bieten Sie weiterhin eine `toString`-Methode an, die diese Informationen wieder ausgibt und denken Sie an Methoden, um später wieder auf die Daten zu den Filmen zugreifen zu können.
+
+Schreiben Sie eine Klasse `Main`, welche alle Lieblingsfilme auf der Konsole ausgibt.

Assignment_040/readme.md

@@ -0,0 +1,15 @@
+# Singleton-Eigenschaft von Enumerationen
+
+
+
+## Lernziel
+
+Die Singleton-Eigenschaft von Enumerationen verstehen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.enums.singleton](../sources/src/main/java/pr2/enums/singleton/).
+
+Enumerationen werden in Java durch echte Klassen und Objekte dargestellt. Eine Besonderheit ist allerdings, dass von jeder Enumerationskonstante immer genau ein Objekt existiert, es sich also um Singletons handelt. Daher darf man Java-Enumerationen sicher mit `==` vergleichen.
+
+Schreiben Sie bitte ein kleines Java-Programm `SingletonBeweis`, das nachweist, dass es sich bei Enumerationen wirklich um Singletons handelt. Verwenden Sie dazu die bereits vorgegebene Enumeration `MyEnum`.

Assignment_041/readme.md

@@ -0,0 +1,23 @@
+# Eine vorhandene Enumeration nutzen
+
+
+
+## Lernziel
+
+Syntax von Enumerationen verstehen und einfache Einsatzzwecke kennenlernen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.enums.verwenden](../sources/src/main/java/pr2/enums/verwenden/).
+
+In dieser Aufgabe sollen Sie mit einer vorhandenen Enumeration experimentieren. Sehen Sie sich hierzu die vorhandenen Klassen an. Insbesondere das Sprite `Professor`.
+
+Im Konstruktor von `Professor` wird eine Enumeration namens `BoundaryPolicy` genutzt. Schauen Sie sich die JavaDoc der Enumeration an und versuchen Sie zu verstehen, was gemeint ist.
+
+Testen Sie nun die verschiedenen Werte der Enumeration durch und betrachten Sie, wie sich das Sprite anders verhält.
+
+Überlegen Sie, warum hier eine Enumeration verwendet wurde und nicht etwas Vererbung mit dem Überschreiben von Methoden.
+
+## Abgabe
+
+Für diese Aufgabe ist keine Abgabe vorgesehen.

Assignment_042/readme.md

@@ -0,0 +1,51 @@
+# Assignment: Stein, Papier, Schere, Echse, Spock
+
+
+
+## Lernziel
+
+Mit Enumerationen arbeiten.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.enums.schnick](../sources/src/main/java/pr2/enums/schnick).
+
+![Regeln für Schnick-Schnack-Schnuck](img/schnick.png)
+
+Schreiben Sie ein einfaches Spiel (Klasse `SchnickSchnackSchnuck`), bei dem Sie gegen den Computer Schnick-Schnack-Schnuck spielen (auch Rock, Paper, Scissors genannt) mit folgenden Eigenschaften:
+
+  * Das Spiel geht über drei Runden.
+  * Es fragt den Spieler nach seiner Auswahl (r, p, s).
+  * Der Computer zieht zufällig eine der drei Möglichkeiten.
+  * Nach jeder Runde sagt das Spiel, wer welche Möglichkeit gewählt hat und wer die Runde gewonnen hat.
+  * Ein Sieg bringt einen Punkt, ein Unentschieden 0 Punkte.
+  * Die Punkte jeder Runde werden addiert.
+  * Am Ende wird der Gesamtpunktestand ausgegeben.
+
+Eine beispielhafte Session mit dem Programm sieht dann wie folgt aus:
+
+```console
+Runde 1: Dein Zug ([r]rock, [p]aper, [s]cissors)? r
+Der Computer hat gewonnen - Du: ROCK, Computer: PAPER - [0:1]
+
+Runde 2: Dein Zug ([r]rock, [p]aper, [s]cissors)? p
+Unentschieden - Du: PAPER, Computer: PAPER - [0:1]
+
+Runde 3: Dein Zug ([r]rock, [p]aper, [s]cissors)? s
+Du hast gewonnen: Du: SCISSORS, Computer: PAPER - [1:1]### Abgabe
+Ergebnis - Du 1 Punkt(e), Computer 1 Punkt(e)
+```
+
+Repräsentieren Sie die Züge mithilfe einer Enumeration `Move`. Diese soll auch die Tasten beinhalten, welche man für die einzelnen Züge (`r`, `p`, `s`) drücken muss.
+
+
+## Abgabe (optional)
+
+__Sie müssen keine Lösung für diese Aufgabe einreichen.__
+
+Sie können Ihre Lösung aber auf die Konformität mit den Programmierstandards testen. Hierzu gehen Sie wie folgt vor:
+
+  1. Öffnen Sie eine Kommandozeile (Terminal).
+  2. Gehen Sie in Ihr Working Directory.
+  3. Wechseln Sie mit `cd` in das Verzeichnis `sources`.
+  4. Bauen Sie das Projekt mit dem Kommando `mvn`.

readme.md

@@ -7,7 +7,7 @@ Hier finden Sie die **freiwilligen Übungen** zur Vorlesung Programmieren 2 (PR2
 Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstattung.md).
 
 | #  | Ausgabe    | Thema                                                                              |
-|----|-------------------------------------------------------------------------|----------------|
+|----|------------------------------------------------------------------------------------|----------------|
 | 1. | 14.03.2023 | [String in Großbuchstaben umwandeln](Assignment_001/readme.md)                     |
 | 2. | 14.03.2023 | [Labeled Break](Assignment_002/readme.md)                                          |
 | 3. | 14.03.2023 | [Passwortbewertung](Assignment_003/readme.md)                                      |
@@ -38,3 +38,15 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 28. | 11.04.2023 | [Interface Stack entwerfen](Assignment_028/readme.md)                              |
 | 29. | 11.04.2023 | [Interface: Uebersetzer](Assignment_029/readme.md)                                 |
 | 30. | 11.04.2023 | [Interfaces anwenden und entwerfen](Assignment_030/readme.md)                      |
+| 31. | 20.04.2023 | [Deep-Copy mit `clone()`](Assignment_031/readme.md)                                |
+| 32. | 20.04.2023 | [Clone](Assignment_032/readme.md)                                                  |
+| 33. | 20.04.2023 | [`equals()` und `hashCode()` implementieren und nutzen](Assignment_033/readme.md)  |
+| 34. | 20.04.2023 | [equals und hashCode](Assignment_034/readme.md)                                    |
+| 35. | 20.04.2023 | [`toString()`-Methode implementieren](Assignment_035/readme.md)                    |
+| 36. | 20.04.2023 | [Optimierung bei Integer](Assignment_036/readme.md)                                |
+| 37. | 20.04.2023 | [Methoden der Wrapper-Klassen](Assignment_037/readme.md)                           |
+| 38. | 20.04.2023 | [Eigene Enumeration schreiben und verwenden](Assignment_038/readme.md)             |
+| 39. | 20.04.2023 | [Enumeration schreiben](Assignment_039/readme.md)                                  |
+| 40. | 20.04.2023 | [Singleton-Eigenschaft von Enumerationen](Assignment_040/readme.md)                |
+| 41. | 20.04.2023 | [Eine vorhandene Enumeration nutzen](Assignment_041/readme.md)                     |
+| 42. | 20.04.2023 | [Stein, Papier, Schere, Echse, Spock](Assignment_042/readme.md)                    |

sources/src/main/java/pr2/enums/eigene/Wuerfel.java

@@ -0,0 +1,52 @@
+package pr2.enums.eigene;
+
+import java.util.Random;
+
+/**
+ * Ein einfacher Würfel.
+ */
+public class Wuerfel {
+
+    /** 4-seitiger Würfel. */
+    public static final int D4 = 4;
+
+    /** 6-seitiger Würfel. */
+    public static final int D6 = 6;
+
+    /** 8-seitiger Würfel. */
+    public static final int D8 = 8;
+
+    /** 10-seitiger Würfel. */
+    public static final int D10 = 10;
+
+    /** 12-seitiger Würfel. */
+    public static final int D12 = 13;
+
+    /**
+     * Zufallszahlengenerator.
+     */
+    private final Random rnd = new Random();
+
+    /**
+     * Anzahl der Seiten des Würfels.
+     */
+    private final int numSides;
+
+    /**
+     * Einen neuen Würfel anlegen.
+     *
+     * @param typ Anzahl der Seiten des Würfels.
+     */
+    public Wuerfel(int numSides) {
+        this.numSides = numSides;
+    }
+
+    /**
+     * Den Würfel werfen.
+     *
+     * @return Ergebnis des Wurfes.
+     */
+    public int roll() {
+        return rnd.nextInt(numSides) + 1;
+    }
+}

sources/src/main/java/pr2/enums/eigene/test/WuerfelTest.java

@@ -0,0 +1,59 @@
+package pr2.enums.eigene.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.enums.eigene.Wuerfel;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Test für die Würfel.
+ */
+public class WuerfelTest {
+
+    /**
+     * Anzahl der Durchläufe (Gesetz der großen Zahl!).
+     */
+    private static final int RUNS = 10000000;
+
+
+    @Test
+    void testFairnessD4() {
+        internalTestFairness(new Wuerfel(Wuerfel.D4), 2.5);
+    }
+
+    @Test
+    void testFairnessD6() {
+        internalTestFairness(new Wuerfel(Wuerfel.D6), 3.5);
+    }
+
+    @Test
+    void testFairnessD8() {
+        internalTestFairness(new Wuerfel(Wuerfel.D8), 4.5);
+    }
+
+    @Test
+    void testFairnessD10() {
+        internalTestFairness(new Wuerfel(Wuerfel.D10), 5.5);
+    }
+
+    @Test
+    void testFairnessD12() {
+        internalTestFairness(new Wuerfel(Wuerfel.D12), 6.5);
+    }
+
+    /**
+     * Interne Hilfsmethode, um die Fairness zu testen.
+     *
+     * @param w        der zu testende Wuerfel.
+     * @param expected Erwartungswert.
+     */
+    private void internalTestFairness(Wuerfel w, double expected) {
+        long sum = 0;
+
+        for (int i = 0; i < RUNS; i++) {
+            sum += w.roll();
+        }
+        double average = (double) sum / (double) RUNS;
+        assertEquals(expected, average, 0.1);
+    }
+}

sources/src/main/java/pr2/enums/filme/LieblingsFilme.java

@@ -0,0 +1,5 @@
+package pr2.enums.filme;
+
+public enum LieblingsFilme {
+
+}

sources/src/main/java/pr2/enums/filme/Main.java

@@ -0,0 +1,7 @@
+package pr2.enums.filme;
+
+public class Main {
+    public static void main(String[] args) {
+        // TODO: Alle Filme ausgeben
+    }
+}

sources/src/main/java/pr2/enums/schnick/Move.java

@@ -0,0 +1,4 @@
+package pr2.enums.schnick;
+
+public enum Move {
+}

sources/src/main/java/pr2/enums/schnick/SchnickSchnackSchnuck.java

@@ -0,0 +1,11 @@
+package pr2.enums.schnick;
+
+import java.util.Random;
+import java.util.Scanner;
+
+/**
+ * Schick - Schnack - Schnuck (Rock - Paper - Scissors).
+ */
+public class SchnickSchnackSchnuck {
+
+}

sources/src/main/java/pr2/enums/singleton/MyEnum.java

@@ -0,0 +1,7 @@
+package pr2.enums.singleton;
+
+enum MyEnum {
+    A,
+    B,
+    C;
+}

sources/src/main/java/pr2/enums/singleton/SingletonBeweis.java

@@ -0,0 +1,8 @@
+package pr2.enums.singleton;
+
+public class SingletonBeweis {
+
+    public static void main(String[] args) {
+        // TODO: Singleton-Eigenschaft zeigen
+    }
+}

sources/src/main/java/pr2/enums/verwenden/GameBoard.java

@@ -0,0 +1,47 @@
+package pr2.enums.verwenden;
+
+import de.smits_net.games.framework.board.Board;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Point;
+
+/**
+ * Spielfeld.
+ */
+public class GameBoard extends Board {
+
+    /**
+     * Sprite, das durch das Bild läuft.
+     */
+    private final Professor sprite;
+
+    /**
+     * Erzeugt ein neues Board.
+     */
+    public GameBoard() {
+        // neues Spielfeld anlegen
+        super(10, new Dimension(400, 400), Color.BLACK);
+
+        // Sprite initialisieren
+        sprite = new Professor(this, new Point(300, 200));
+    }
+
+    /**
+     * Spielfeld neu zeichnen. Wird vom Framework aufgerufen.
+     */
+    @Override
+    public void drawGame(Graphics g) {
+        sprite.draw(g, this);
+    }
+
+    /**
+     * Spielsituation updaten. Wird vom Framework aufgerufen.
+     */
+    @Override
+    public boolean updateGame() {
+        sprite.move();
+        return sprite.isVisible();
+    }
+}

sources/src/main/java/pr2/enums/verwenden/GameMain.java

@@ -0,0 +1,28 @@
+package pr2.enums.verwenden;
+
+import de.smits_net.games.framework.board.MainWindow;
+
+import java.awt.EventQueue;
+
+/**
+ * Hauptklasse des Spiels.
+ */
+public class GameMain extends MainWindow {
+
+    /**
+     * Neues Spiel anlegen.
+     */
+    public GameMain() {
+        super("Watch me walk...", new GameBoard());
+    }
+
+    /**
+     * Startpunkt.
+     *
+     * @param args command line arguments.
+     */
+    public static void main(String[] args) {
+        // Spiel starten
+        EventQueue.invokeLater(GameMain::new);
+    }
+}

sources/src/main/java/pr2/enums/verwenden/Professor.java

@@ -0,0 +1,32 @@
+package pr2.enums.verwenden;
+
+import de.smits_net.games.framework.board.Board;
+import de.smits_net.games.framework.image.AnimatedImage;
+import de.smits_net.games.framework.sprite.AnimatedSprite;
+import de.smits_net.games.framework.sprite.Direction;
+
+import java.awt.Point;
+
+/**
+ * Ein Sprite.
+ */
+public class Professor extends AnimatedSprite {
+
+    /**
+     * Geschwindigkeit der Figur in X-Richtung.
+     */
+    private static final int SPRITE_SPEED = 2;
+
+    /**
+     * Neues Sprite anlegen.
+     *
+     * @param board      das Spielfeld
+     * @param startPoint Start-Position
+     */
+    public Professor(Board board, Point startPoint) {
+        super(board, startPoint, BoundaryPolicy.NONE,
+                new AnimatedImage(50, 9,
+                        "pr2/enums/use/professor_left"));
+        velocity.setVelocity(Direction.WEST, SPRITE_SPEED);
+    }
+}

sources/src/main/java/pr2/object/clone_alien/Alien.java

@@ -0,0 +1,91 @@
+package pr2.object.clone_alien;
+
+/**
+ * Ein Alien.
+ */
+ public class Alien {
+
+    /**
+     * Name des Aliens.
+     */
+    private final String name;
+
+    /**
+     * Raumanzug des Aliens.
+     */
+    private Raumanzug raumanzug;
+
+    /**
+     * Erzeugt ein neues Alien.
+     *
+     * @param name      Name des Aliens.
+     * @param raumanzug Anzug.
+     */
+    public Alien(String name, Raumanzug raumanzug) {
+        this.name = name;
+        this.raumanzug = raumanzug;
+    }
+
+    /**
+     * Gibt den Namen des Aliens zurück.
+     *
+     * @return Name des Aliens.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gibt den Anzug zurück.
+     *
+     * @return der Anzug.
+     */
+    public Raumanzug getAnzug() {
+        return raumanzug;
+    }
+
+    /**
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
+        result = prime * result + ((raumanzug
+                == null) ? 0 : raumanzug.hashCode());
+        return result;
+    }
+
+    /**
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        Alien other = (Alien) obj;
+        if (name == null) {
+            if (other.name != null) {
+                return false;
+            }
+        }
+        else if (!name.equals(other.name)) {
+            return false;
+        }
+        if (raumanzug == null) {
+            return other.raumanzug == null;
+        }
+        else {
+            return raumanzug.equals(other.raumanzug);
+        }
+    }
+
+}

sources/src/main/java/pr2/object/clone_alien/Raumanzug.java

@@ -0,0 +1,68 @@
+package pr2.object.clone_alien;
+
+/**
+ * Ein Raumanzug.
+ */
+ public class Raumanzug {
+
+    /**
+     * Sauerstoffvorrat, der noch im Raumanzug ist.
+     */
+    private double sauerstoffVorrat;
+
+    /**
+     * Ertzeugt einen neuen Raumanzug.
+     */
+    public Raumanzug() {
+        sauerstoffVorrat = Math.random();
+    }
+
+    /**
+     * Sauerstoffvorrat im Anzug.
+     *
+     * @return Vorrat in % (0.0-1.0)
+     */
+    public double getSauerstoffVorrat() {
+        return sauerstoffVorrat;
+    }
+
+    /**
+     * Tankt den Anzug auf.
+     */
+    public void auftanken() {
+        sauerstoffVorrat = 1.0;
+    }
+
+    /**
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(sauerstoffVorrat);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    /**
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        Raumanzug other = (Raumanzug) obj;
+        return Double.doubleToLongBits(sauerstoffVorrat)
+                == Double.doubleToLongBits(other.sauerstoffVorrat);
+    }
+
+}

sources/src/main/java/pr2/object/clone_alien/test/AlienCloneTest.java

@@ -0,0 +1,38 @@
+package pr2.object.clone_alien.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.object.clone_alien.Alien;
+import pr2.object.clone_alien.Raumanzug;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
+/**
+ * Test für die Clone-Methoden.
+ */
+public class AlienCloneTest {
+
+    /**
+     * Test-Methode.
+     *
+     * @throws CloneNotSupportedException wird geworfen, wenn clone_alien
+     *                                    nicht korrekt implementiert wurde.
+     */
+    @Test
+    void testClone() throws CloneNotSupportedException {
+// TODO: Einkommentieren
+//        Raumanzug r1 = new Raumanzug();
+//        Alien a1 = new Alien("Predator", r1);
+//
+//        Alien a2 = (Alien) a1.clone();
+//        Raumanzug r2 = a2.getAnzug();
+//
+//        assertNotSame(a1, a2);
+//        assertNotSame(r1, r2);
+//
+//        assertEquals(a1, a2);
+//        assertEquals(r1, r2);
+//        assertEquals(r1.getSauerstoffVorrat(), r2.getSauerstoffVorrat(),
+//                0.0001);
+    }
+}

sources/src/main/java/pr2/object/clone_person/Person.java

@@ -0,0 +1,22 @@
+package pr2.object.clone_person;
+
+import java.util.Date;
+
+ public class Person {
+
+    private final String vorname = "";
+    private final String nachname = "";
+    private Date geburtsdatum = new Date();
+
+    // TODO: clone implementieren
+
+
+    @Override
+    public String toString() {
+        return "Person{"
+                + "vorname='" + vorname + '\''
+                + ", nachname='" + nachname + '\''
+                + ", geburtsdatum=" + geburtsdatum
+                + '}';
+    }
+}

sources/src/main/java/pr2/object/equals_hashcode/Ork.java

@@ -0,0 +1,29 @@
+package pr2.object.equals_hashcode;
+
+/**
+ * Ork.
+ */
+public class Ork extends Wesen {
+
+    /**
+     * Stärke der Orks.
+     */
+    private static final int ORK_STAERKE = 17;
+
+    /**
+     * Zeigt an, ob der Ork gut oder böse ist.
+     */
+    private final boolean boese;
+
+    /**
+     * Legt einen neuen Ork an.
+     *
+     * @param name  Name des Orks.
+     * @param boese zeigt an, ob der Ork gut oder böse ist
+     */
+    public Ork(String name, boolean boese) {
+        super(name, ORK_STAERKE);
+        this.boese = boese;
+    }
+
+}

sources/src/main/java/pr2/object/equals_hashcode/Wesen.java

@@ -0,0 +1,29 @@
+package pr2.object.equals_hashcode;
+
+/**
+ * Ein Wesen in der Spielwelt.
+ */
+public class Wesen {
+
+    /**
+     * Name des Wesens.
+     */
+    private final String name;
+
+    /**
+     * Stärke des Wesens.
+     */
+    private final int staerke;
+
+    /**
+     * Legt ein neues Wesen an.
+     *
+     * @param name    Name des Wesens.
+     * @param staerke Stärke des Wesens.
+     */
+    public Wesen(String name, int staerke) {
+        this.name = name;
+        this.staerke = staerke;
+    }
+
+}

sources/src/main/java/pr2/object/equals_hashcode/test/WesenTest.java

@@ -0,0 +1,87 @@
+package pr2.object.equals_hashcode.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.object.equals_hashcode.Ork;
+import pr2.object.equals_hashcode.Wesen;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
+/**
+ * Testklasse für die Wesen.
+ */
+public class WesenTest {
+
+    /**
+     * Testet equals und hashCode von Wesen.
+     */
+    @Test
+    void testWesen() {
+        Wesen w1 = new Wesen("Azok", 30);
+        Wesen w2 = new Wesen("Azok", 30);
+        Wesen w3 = new Wesen("Azok", 31);
+        Wesen w4 = new Wesen("Gorrok", 30);
+        Wesen w5 = new Wesen("Gorrok", 31);
+
+        assertNotSame(w1, w2);
+        assertEquals(w1, w2);
+
+        assertNotSame(w1, w3);
+        assertNotEquals(w1, w3);
+
+        assertNotSame(w1, w4);
+        assertNotEquals(w1, w4);
+
+        assertNotSame(w1, w5);
+        assertNotEquals(w1, w5);
+
+        assertEquals(w1.hashCode(), w2.hashCode());
+    }
+
+    /**
+     * Testet equals und hashCode von Ork.
+     */
+    @Test
+    void testOrk() {
+        Ork o1 = new Ork("Snagas", true);
+        Ork o2 = new Ork("Snagas", true);
+        Ork o3 = new Ork("Snagas", false);
+        Ork o4 = new Ork("Berg-Ork", false);
+        Ork o5 = new Ork("Berg-Ork", true);
+        Ork o6 = new Ork("Berg-Ork", false);
+        Wesen w = new Wesen("Snagas", 17);
+
+        assertNotSame(o1, o2);
+        assertEquals(o1, o2);
+
+        assertNotSame(o1, o3);
+        assertNotEquals(o1, o3);
+
+        assertNotSame(o1, o4);
+        assertNotEquals(o1, o4);
+
+        assertNotSame(o1, o5);
+        assertNotEquals(o1, o5);
+
+        assertEquals(o1.hashCode(), o2.hashCode());
+        assertEquals(o4.hashCode(), o6.hashCode());
+
+        assertNotEquals(w, o1);
+        assertNotEquals(w, o2);
+        assertNotEquals(w, o3);
+        assertNotEquals(null, o1);
+        assertNotEquals("Hugo", o1);
+        assertEquals(o1, o1);
+
+        // Diese Tests muss nicht zwangsweise funktionieren, da
+        // ungleiche Objekte einen identischen Hashcode haben können.
+        // Wir gehen hier aber davon aus, dass eine Hashkollision
+        // sehr selten ist und machen daher aus didaktischen Gründen
+        // diesen Test.
+        assertNotEquals(o1.hashCode(), o3.hashCode());
+        assertNotEquals(o1.hashCode(), o4.hashCode());
+        assertNotEquals(o1.hashCode(), o5.hashCode());
+        assertNotEquals(o4.hashCode(), o5.hashCode());
+    }
+}

sources/src/main/java/pr2/object/equals_person/Person.java

@@ -0,0 +1,10 @@
+package pr2.object.equals_person;
+
+public class Person {
+
+    private String vorname;
+    private String nachname;
+    private int alter;
+
+    // TODO: equals und hashCode implementieren
+}

sources/src/main/java/pr2/object/tostring/Alien.java

@@ -0,0 +1,47 @@
+package pr2.object.tostring;
+
+/**
+ * Ein Alien.
+ */
+public class Alien implements Cloneable {
+
+    /**
+     * Name des Aliens.
+     */
+    private final String name;
+
+    /**
+     * Raumanzug des Aliens.
+     */
+    private final Raumanzug raumanzug;
+
+    /**
+     * Erzeugt ein neues Alien.
+     *
+     * @param name      Name des Aliens.
+     * @param raumanzug Anzug.
+     */
+    public Alien(String name, Raumanzug raumanzug) {
+        this.name = name;
+        this.raumanzug = raumanzug;
+    }
+
+    /**
+     * Gibt den Namen des Aliens zurück.
+     *
+     * @return Name des Aliens.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gibt den Anzug zurück.
+     *
+     * @return der Anzug.
+     */
+    public Raumanzug getAnzug() {
+        return raumanzug;
+    }
+
+}

sources/src/main/java/pr2/object/tostring/Ausgabe.java

@@ -0,0 +1,24 @@
+package pr2.object.tostring;
+
+/**
+ * Ausgabe.
+ */
+public final class Ausgabe {
+
+    /**
+     * Konstruktor.
+     */
+    private Ausgabe() {
+        // keine Objekte.
+    }
+
+    /**
+     * Einstiegspunkt in das Programm.
+     *
+     * @param args Kommandozeilenargumente.
+     */
+    public static void main(String[] args) {
+        Alien alien = new Alien("E.T.", new Raumanzug("Spaceman 2000"));
+        System.out.println(alien);
+    }
+}

sources/src/main/java/pr2/object/tostring/Raumanzug.java

@@ -0,0 +1,44 @@
+package pr2.object.tostring;
+
+/**
+ * Ein Raumanzug.
+ */
+public class Raumanzug implements Cloneable {
+
+    /**
+     * Hersteller des Raumanzuges.
+     */
+    private final String hersteller;
+
+    /**
+     * Sauerstoffvorrat, der noch im Raumanzug ist.
+     */
+    private double sauerstoffVorrat;
+
+    /**
+     * Ertzeugt einen neuen Raumanzug.
+     *
+     * @param hersteller Hersteller des Anzuges.
+     */
+    public Raumanzug(String hersteller) {
+        this.hersteller = hersteller;
+        sauerstoffVorrat = Math.random();
+    }
+
+    /**
+     * Sauerstoffvorrat im Anzug.
+     *
+     * @return Vorrat in % (0.0-1.0)
+     */
+    public double getSauerstoffVorrat() {
+        return sauerstoffVorrat;
+    }
+
+    /**
+     * Tankt den Anzug auf.
+     */
+    public void auftanken() {
+        sauerstoffVorrat = 1.0;
+    }
+
+}

sources/src/main/java/pr2/object/wrapper_boxsearch/BoxSearcher.java

@@ -0,0 +1,8 @@
+package pr2.object.wrapper_boxsearch;
+
+public class BoxSearcher {
+
+    public static void main(String[] args) {
+        // TODO: Grenze suchen und Ergebnis ausgeben
+    }
+}

sources/src/main/java/pr2/object/wrapper_umwandler/Umwandler.java

@@ -0,0 +1,45 @@
+package pr2.object.wrapper_umwandler;
+
+/**
+ * Enthält Methoden, um Integer-Zahlen umzuwandeln.
+ */
+public final class Umwandler {
+
+    /**
+     * Konstruktor.
+     */
+    private Umwandler() {
+        // keine Instanzen
+    }
+
+    /**
+     * Wandelt eine Zahl in meherer Formate um.
+     *
+     * @param i die Zahl.
+     * @return String mit mehreren Formaten.
+     */
+    public static String toString(int i) {
+        return null;
+    }
+
+    /**
+     * Wandelt einen String (zur Basis 10) in eine Zahl um.
+     *
+     * @param s String, der umgewandelt werden soll
+     * @return Umgewandelte Zahl
+     */
+    public static int fromString(String s) {
+        return 0;
+    }
+
+    /**
+     * Einstiegspunkt in das Programm.
+     *
+     * @param args Kommandozeilenargumente.
+     */
+    public static void main(String[] args) {
+        String s = "17871";
+        int i = fromString(s);
+        System.out.println(toString(i));
+    }
+}