Update of exercises

Assignment_043/readme.md

@@ -0,0 +1,29 @@
+# Ausnahmen testen
+
+
+
+## Lernziel
+
+Bei einer gegebenen Klasse Testfälle mit JUnit schreiben, die auf das Werfen von Ausnahmen testen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.exceptions.ausnahmen_testen](../sources/src/main/java/pr2/exceptions/ausnahmen_testen/).
+
+Sie finden in der Aufgabe eine einfache Implementierung einer [Caesar-Verschlüsselung](https://de.wikipedia.org/wiki/Caesar-Verschlüsselung) in der Klasse `CrypterCaesar`. Außerdem finden Sie noch einen JUnit-Test in dem entsprechenden Paket `test`.
+
+Im JUnit-Test `CaesarTest` fehlen aber noch die Tests für die Ausnahmen. Diese werden geworfen, wenn die übergebenen Schlüssel bzw. die Klar- und Cypher-Texte nicht den Vorgaben entsprechen. Lesen Sie daher sorgfältig die JavaDoc der Klasse `CrypterCaesar` und fügen Sie dann entsprechende Testfälle in  `CaesarTest` hinzu, die auf das korrekte Werfen der Ausnahmen testen.
+
+Lassen Sie Ihre Unit-Tests laufen und testen Sie, ob die Ausnahmen entsprechend der Vorgaben aus der JavaDoc geworfen werden.
+
+
+## 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_044/readme.md

@@ -0,0 +1,33 @@
+# Eigene Ausnahmen schreiben und an entsprechender Stelle werfen
+
+
+
+## Lernziel
+
+Ausnahmen programmieren und sinnvoll einsetzen. Bedeutung der Schlüsselwörter `throws` und `throw` verstehen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.exceptions.eigene_ausnahme](../sources/src/main/java/pr2/exceptions/eigene_ausnahme/).
+
+In der vorliegenden Aufgabe sollen Sie eine Sicherung (`Fuse`) programmieren. Sicherungen gibt es (in unserer Modellwelt) nur für 16, 25 und 32 Ampére.
+
+Beim Anlegen erfährt die Sicherung über den Konstruktor bei welchem Strom sie auslösen soll. Hierbei soll es nur möglich sein, Sicherungen in den vorhandenen Stärken anzulegen. Bei jedem anderen Wert soll der Konstruktor eine `IllegalCurrentException` werfen. In der Ausnahme soll gespeichert werden, mit welchem (falschen) Wert die Sicherung angelegt werden sollte. Diese Information wird beim Aufruf von `toString()` auf der Ausnahme wieder zurückgegeben.
+
+Die Sicherung wird benutzt, indem die `use`-Methode mit dem aktuellen Strom aufgerufen wird. Ist dieser größer als der Nennstrom der Sicherung löst diese aus und wirft eine `FuseTrippedException`. In der Ausnahme sind sowohl der Nennstrom als auch der Auslösestrom gespeichert und werden in der `toString`-Methode ausgegeben.
+
+Beachten Sie die TODO-Kommentare und passen Sie das Programm entsprechend an, damit es die oben beschriebenen Anforderungen erfüllt.
+
+Kommentieren Sie die Tests ein und lassen Sie diese laufen. Erst wenn alle Tests grün sind, gilt die Aufgabe als bestanden.
+
+
+## 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_045/readme.md

@@ -0,0 +1,25 @@
+# Eigene Exception schreiben
+
+
+
+## Lernziel
+
+Eigene Exceptions entwerfen und verwenden.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.exceptions.fakultaet](../sources/src/main/java/pr2/exceptions/fakultaet/).
+
+Schreiben Sie bitte eine Klasse `Fakultaet`, die die Fakultät einer Zahl zwischen 0 und 20 berechnen kann. Wenn der Wertebereich über- oder unterschritten wird, soll die entsprechende Methode der Klasse eine `FakultaetException` werfen. Schreiben Sie weiterhin einen JUnit-Test, der sowohl die korrekte Funktion, als auch das Werfen der Ausnahme überprüft.
+
+
+## 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_046/readme.md

@@ -0,0 +1,30 @@
+# Handle-or-Declare-Regel anwenden
+
+
+
+## Lernziel
+
+In einem vorhandenen Programm die Ausnahmen korrekt weiter deklarieren und an den richtigen Stellen fangen.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.exceptions.handle_or_declare](../sources/src/main/java/pr2/exceptions/handle_or_declare/).
+
+Entfernen Sie auskommentierten Zeilen in der Klasse `Buchstabenzaehler`. Das Programm wird nicht korrekt kompilieren, weil die Ausnahmen nicht richtig deklariert und behandelt wurden.
+
+Korrigieren Sie diesen Fehler und sorgen Sie dafür, dass die Ausnahmen an den Stellen behandelt werden, an denen Sie behandelt werden sollten, d.h. dort wo die Verursachung liegt. Bei der `StatistikException` handelt es sich um eine Inkonsistenz im Programm. Überlegen Sie, wo diese behandelt werden sollte und wann sie auftreten kann.
+
+Sie müssen die Ausnahmen sinnvoll behandeln. Sie einfach an der `main`-Methode
+zu deklarieren ist keine valide Lösung dieser Aufgabe.
+
+
+## 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_047/readme.md

@@ -0,0 +1,29 @@
+# Ausnahmen mit `try` und `catch` behandeln.
+
+
+
+## Lernziel
+
+Vorhandene Ausnahmen mit `try` und `catch` abfangen und behandeln.
+
+## Aufgabe
+
+Gehen Sie in das Paket [pr2.exceptions.try_catch](../sources/src/main/java/pr2/exceptions/try_catch/).
+
+Betrachten Sie das sehr einfache Zahlenraten-Spiel. Lassen Sie es laufen und spielen Sie ein paar Runden. Versuchen Sie das Programm durch falsche Eingaben zum Absturz zu bringen.
+
+Im Augenblick werden die Ausnahmen in der `main()`-Methode weiter deklariert, was schlechter Stil ist und zu bei Falscheingaben zu Programmabstürzen führt. Ändern Sie das Programm stattdessen so ab, dass die Ausnahmen korrekt behandelt werden. Entfernen Sie danach die `throws`-Deklaration aus dem Kopf der `main()`-Methode.
+
+Lassen Sie das Programm erneut laufen und testen Sie, ob es jetzt nach Falscheingaben immer noch abstürzt.
+
+
+## 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)                                               |
@@ -50,3 +50,8 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
 | 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)                             |
+| 43. | 27.04.2023 | [Ausnahmen testen](Assignment_043/readme.md)                                                |
+| 44. | 27.04.2023 | [Eigene Ausnahmen schreiben und an entsprechender Stelle werfen](Assignment_044/readme.md)  |
+| 45. | 27.04.2023 | [Eigene Exception schreiben](Assignment_045/readme.md)                                      |
+| 46. | 27.04.2023 | [Handle-or-Declare-Regel anwenden](Assignment_046/readme.md)                                |
+| 47. | 27.04.2023 | [Ausnahmen mit `try` und `catch` behandeln.](Assignment_047/readme.md)                      |

sources/src/main/java/pr2/exceptions/ausnahmen_testen/CrypterCaesar.java

@@ -0,0 +1,164 @@
+package pr2.exceptions.ausnahmen_testen;
+
+/**
+ * Implementierung einer Caesar-Verschlüsselung.
+ * <p>
+ * Der Eingabetext ({@literal message}) darf nur aus den Groß-Buchstaben A-Z
+ * bestehen. Alle anderen Zeichen (einschließlich der Leerzeichen) führen zu
+ * einer entsprechenden Ausnahme.
+ * <p>
+ * Dasselbe gilt für die Entschlüsselung. Auch hier dürfen nur gültige
+ * Zeichen auftauchen. Andernfalls kommt es zu einer Ausnahme.
+ * <p>
+ * Der Schlüssel darf nur aus einem einzelnen Zeichen bestehen und muss
+ * ebenfalls aus dem Bereich A-Z stammen. Kleinbuchstaben oder andere
+ * Zeichen führen zu einer Ausnahme.
+ * <p>
+ * Zwischen den beiden Methoden muss bei gleichem Schlüssel {@code key}
+ * folgendes gelten:
+ * <p>
+ * {@code text.equals(decrypt(key, encrypt(key, text)) == true}.
+ */
+public class CrypterCaesar {
+
+    /**
+     * Gültige Zeichen für Schlüssel und Text.
+     */
+    protected static final String ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+    /**
+     * Verschlüsselt den gegebenen Text mit dem angegebenen Schlüssel.
+     *
+     * @param key     Schlüssel, der verwendet werden soll.
+     * @param message Nachricht, die Verschlüsselt werden soll.
+     * @return verschlüsselter Text.
+     * @throws IllegalMessageException Wird geworfen, wenn die
+     *                                 Nachricht ungültig ist.
+     * @throws IllegalKeyException     Wird geworfen, wenn der Schlüssel
+     *                                 ungültig ist.
+     */
+    public String encrypt(String key, String message)
+            throws IllegalMessageException, IllegalKeyException {
+
+        checkKeyAndMessage(key, message);
+
+        int shift = key.charAt(0) - 'A' + 1;
+        return shift(message, shift);
+    }
+
+    /**
+     * Entschlüsselt den gegebenen Text mit dem angegebenen Schlüssel.
+     *
+     * @param key        Schlüssel, der verwendet werden soll.
+     * @param cypherText Nachricht, die entschlüsselt werden soll.
+     * @return entschlüsselter Text.
+     * @throws IllegalMessageException Wird geworfen, wenn die
+     *                                 Nachricht ungültig ist.
+     * @throws IllegalKeyException     Wird geworfen, wenn der Schlüssel
+     *                                 ungültig ist.
+     */
+    public String decrypt(String key, String cypherText)
+            throws IllegalKeyException, IllegalMessageException {
+
+        checkKeyAndMessage(key, cypherText);
+
+        int shift = key.charAt(0) - 'A' + 1;
+        return shift(cypherText, -shift);
+    }
+
+    /**
+     * Verschiebt die Zeichen im Text um den gegebenen Faktor.
+     *
+     * @param text  Nachricht
+     * @param shift Verschiebefaktor
+     * @return das Ergebnis als String
+     */
+    private String shift(String text, int shift) {
+
+        StringBuilder result = new StringBuilder();
+
+        for (char c : text.toCharArray()) {
+            char newChar = (char) (c + shift);
+
+            if (newChar > 'Z') {
+                // Überlauf nach hinten
+                newChar = (char) (newChar - ('Z' - 'A' + 1));
+            }
+            else if (newChar < 'A') {
+                // Überlauf nach vorne
+                newChar = (char) (newChar + ('Z' - 'A' + 1));
+            }
+
+            result.append(newChar);
+        }
+
+        return result.toString();
+    }
+
+    /**
+     * Prüft Schlüssel und Nachricht.
+     *
+     * @param key     der Schlüssel
+     * @param message die Nachricht
+     * @throws IllegalKeyException     Schlüssel nicht OK
+     * @throws IllegalMessageException Nachricht nicht OK
+     */
+    private void checkKeyAndMessage(String key, String message)
+            throws IllegalKeyException, IllegalMessageException {
+
+        if (!checkKey(key)) {
+            throw new IllegalKeyException(key);
+        }
+
+        if (!checkCharacters(message, ALPHABET)) {
+            throw new IllegalMessageException(key);
+        }
+    }
+
+    /**
+     * Testet den Schlüssel auf Korrektheit: Er muss mindestens die Länge 1
+     * haben und darf nur Zeichen von A-Z enthalten.
+     *
+     * @param key zu testender Schlüssel
+     * @return {@code true} if characters are ok, otherwise {@code false}
+     */
+    protected boolean checkKey(String key) {
+
+        if (key.length() != 1) {
+            return false;
+        }
+
+        return checkCharacters(key, ALPHABET);
+    }
+
+    /**
+     * Checks the given input to ensure that it only contains the given
+     * character set and no other characters.
+     *
+     * @param inputChars the string to be checked
+     * @param charSet    a string containing all allowed characters
+     * @return {@code true} if characters are ok, otherwise {@code false}
+     */
+    protected boolean checkCharacters(char[] inputChars, String charSet) {
+
+        for (char c : inputChars) {
+            if (charSet.indexOf(c) == -1) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Checks the given input to ensure that it only contains the given
+     * character set and no other characters.
+     *
+     * @param input   the string to be checked
+     * @param charSet a string containing all allowed characters
+     * @return {@code true} if characters are ok, otherwise {@code false}
+     */
+    protected boolean checkCharacters(String input, String charSet) {
+        return checkCharacters(input.toCharArray(), charSet);
+    }
+}

sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalKeyException.java

@@ -0,0 +1,31 @@
+package pr2.exceptions.ausnahmen_testen;
+
+/**
+ * Ungültiger Schlüssel.
+ */
+public class IllegalKeyException extends Exception {
+
+    /**
+     * Legt eine neue Ausnahme an.
+     */
+    public IllegalKeyException() {
+        super();
+    }
+
+    /**
+     * Legt eine neue Ausnahme an.
+     *
+     * @param message die Nachricht.
+     */
+    public IllegalKeyException(String message) {
+        super(message);
+    }
+
+    /**
+     * @see java.lang.Throwable#toString()
+     */
+    @Override
+    public String toString() {
+        return getMessage();
+    }
+}

sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalMessageException.java

@@ -0,0 +1,31 @@
+package pr2.exceptions.ausnahmen_testen;
+
+/**
+ * Ungültige Nachricht.
+ */
+public class IllegalMessageException extends Exception {
+
+    /**
+     * Legt eine neue Ausnahme an.
+     */
+    public IllegalMessageException() {
+        super();
+    }
+
+    /**
+     * Legt eine neue Ausnahme an.
+     *
+     * @param message die Nachricht.
+     */
+    public IllegalMessageException(String message) {
+        super(message);
+    }
+
+    /**
+     * @see java.lang.Throwable#toString()
+     */
+    @Override
+    public String toString() {
+        return getMessage();
+    }
+}

sources/src/main/java/pr2/exceptions/ausnahmen_testen/test/CaesarTest.java

@@ -0,0 +1,36 @@
+package pr2.exceptions.ausnahmen_testen.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import pr2.exceptions.ausnahmen_testen.CrypterCaesar;
+import pr2.exceptions.ausnahmen_testen.IllegalKeyException;
+import pr2.exceptions.ausnahmen_testen.IllegalMessageException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+/**
+ * Testklasse für die Verschlüsselung.
+ */
+public class CaesarTest {
+
+    // TODO: Tests für die Ausnahmen hinzufügen
+
+    /**
+     * Testet die Verschlüsselung an sich.
+     *
+     * @throws IllegalMessageException Wird geworfen, wenn die
+     *                                 Nachricht ungültig ist.
+     * @throws IllegalKeyException     Wird geworfen, wenn der Schlüssel
+     *                                 ungültig ist.
+     */
+    @Test
+    void testCaesar()
+            throws IllegalKeyException, IllegalMessageException {
+        String klarText = "KATHARGOMUSSFALLEN";
+        CrypterCaesar c = new CrypterCaesar();
+        assertEquals(klarText, c.decrypt("C", c.encrypt("C", klarText)));
+        assertEquals("FDHVDU", c.encrypt("C", "CAESAR"));
+        assertEquals(klarText, c.encrypt("Z", klarText));
+    }
+}

sources/src/main/java/pr2/exceptions/eigene_ausnahme/Fuse.java

@@ -0,0 +1,49 @@
+package pr2.exceptions.eigene_ausnahme;
+
+/**
+ * Eine Sicherung im Stromkreis.
+ */
+public class Fuse {
+
+    /**
+     * 16 Ampere-Sicherung.
+     */
+    public static final int A16 = 16;
+
+    /**
+     * 25 Ampere-Sicherung.
+     */
+    public static final int A25 = 25;
+
+    /**
+     * 32 Ampere-Sicherung.
+     */
+    public static final int A32 = 32;
+
+    /**
+     * Strom, bei dem die Sicherung auslöst.
+     */
+    private final int tripCurrent;
+
+    /**
+     * Legt eine neue Sicherung an.
+     *
+     * @param tripCurrent Strom, bei dem die Sicherung auslösen soll.
+     * @throws IllegalCurrentException Ausnahme bei einem
+     *                                 ungültigen Spannungswert.
+     */
+    public Fuse(int tripCurrent) {
+        // TODO: FuseTrippedException werfen, wenn der Strom zu groß ist
+        this.tripCurrent = tripCurrent;
+    }
+
+    /**
+     * Die Sicherung benutzen.
+     *
+     * @param current Strom, der durch die Sicherung fließt.
+     * @throws FuseTrippedException wird geworfen, wenn der Srom zu groß wird.
+     */
+    public void use(int current) {
+        // TODO: FuseTrippedException werfen, wenn der Strom zu groß ist
+    }
+}

sources/src/main/java/pr2/exceptions/eigene_ausnahme/FuseTrippedException.java

@@ -0,0 +1,9 @@
+package pr2.exceptions.eigene_ausnahme;
+
+/**
+ * Ausnahme, wenn die Sicherung auslöst.
+ */
+ public class FuseTrippedException {
+    // TODO: zu einer Ausnahme machen
+    // TODO: Nennstrom und Auslösestrom speichern und in toString wieder ausgeben
+}

sources/src/main/java/pr2/exceptions/eigene_ausnahme/IllegalCurrentException.java

@@ -0,0 +1,9 @@
+package pr2.exceptions.eigene_ausnahme;
+
+/**
+ * Ausnahme, wenn eine Sicherung angelegt werden soll, die es nicht gibt.
+ */
+ public class IllegalCurrentException {
+    // TODO: zu einer Ausnahme machen
+    // TODO: Nennstrom speichern, mit dem die Sicherung angelegt werden sollte.
+}

sources/src/main/java/pr2/exceptions/eigene_ausnahme/test/FuseTest.java

@@ -0,0 +1,159 @@
+package pr2.exceptions.eigene_ausnahme.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import pr2.exceptions.eigene_ausnahme.Fuse;
+import pr2.exceptions.eigene_ausnahme.FuseTrippedException;
+import pr2.exceptions.eigene_ausnahme.IllegalCurrentException;
+
+/**
+ * Testet die Sicherung.
+ */
+public class FuseTest {
+
+// TODO: Quellcode wieder einkommentieren
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit gültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid() throws IllegalCurrentException {
+//        new Fuse(Fuse.A16);
+//        new Fuse(Fuse.A25);
+//        new Fuse(Fuse.A32);
+//    }
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit ungültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid1() throws IllegalCurrentException {
+//        Assertions.assertThrows(IllegalCurrentException.class, () -> {
+//            new Fuse(15);
+//        });
+//    }
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit ungültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid2() throws IllegalCurrentException {
+//        Assertions.assertThrows(IllegalCurrentException.class, () -> {
+//            new Fuse(-1);
+//        });
+//    }
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit ungültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid3() throws IllegalCurrentException {
+//        Assertions.assertThrows(IllegalCurrentException.class, () -> {
+//            new Fuse(0);
+//        });
+//    }
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit ungültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid4() throws IllegalCurrentException {
+//        Assertions.assertThrows(IllegalCurrentException.class, () -> {
+//            new Fuse(Integer.MAX_VALUE);
+//        });
+//    }
+//
+//    /**
+//     * Testet die Erzeugung von Sicherungen mit ungültigen Werten.
+//     *
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testCreationValid5() throws IllegalCurrentException {
+//        Assertions.assertThrows(IllegalCurrentException.class, () -> {
+//            new Fuse(Integer.MIN_VALUE);
+//        });
+//    }
+//
+//    /**
+//     * Testet das Auslösen der Sicherung.
+//     *
+//     * @throws FuseTrippedException    Sicherung hat ausgelöst.
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testTripping1()
+//            throws FuseTrippedException, IllegalCurrentException {
+//
+//        Fuse f = new Fuse(Fuse.A16);
+//        f.use(5);
+//        f.use(16);
+//        f.use(0);
+//
+//        f = new Fuse(Fuse.A25);
+//        f.use(5);
+//        f.use(16);
+//        f.use(25);
+//
+//
+//        Assertions.assertThrows(FuseTrippedException.class, () -> {
+//            Fuse f2 = new Fuse(Fuse.A32);
+//            f2.use(0);
+//            f2.use(16);
+//            f2.use(25);
+//        });
+//    }
+//
+//    /**
+//     * Testet das Auslösen der Sicherung.
+//     *
+//     * @throws FuseTrippedException    Sicherung hat ausgelöst.
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testTripping2()
+//            throws FuseTrippedException, IllegalCurrentException {
+//        Assertions.assertThrows(FuseTrippedException.class, () -> {
+//            new Fuse(Fuse.A16).use(17);
+//        });
+//    }
+//
+//    /**
+//     * Testet das Auslösen der Sicherung.
+//     *
+//     * @throws FuseTrippedException    Sicherung hat ausgelöst.
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testTripping3()
+//            throws FuseTrippedException, IllegalCurrentException {
+//
+//        Assertions.assertThrows(FuseTrippedException.class, () -> {
+//            new Fuse(Fuse.A16).use(Integer.MAX_VALUE);
+//        });
+//    }
+//
+//    /**
+//     * Testet das Auslösen der Sicherung.
+//     *
+//     * @throws FuseTrippedException    Sicherung hat ausgelöst.
+//     * @throws IllegalCurrentException ungültiger Wert für die Sicherung.
+//     */
+//    @Test
+//    void testTripping4()
+//            throws FuseTrippedException, IllegalCurrentException {
+//        Assertions.assertThrows(FuseTrippedException.class, () -> {
+//            new Fuse(Fuse.A32).use(40);
+//        });
+//    }
+}

sources/src/main/java/pr2/exceptions/fakultaet/Fakultaet.java

@@ -0,0 +1,12 @@
+package pr2.exceptions.fakultaet;
+
+public class Fakultaet {
+
+    public int fact(int n) {
+        return factIntern(n);
+    }
+
+    private int factIntern(int n) {
+        return 0;
+    }
+}

sources/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java

@@ -0,0 +1,5 @@
+package pr2.exceptions.fakultaet;
+
+ public class FakultaetException {
+
+}

sources/src/main/java/pr2/exceptions/fakultaet/test/FakultaetTest.java

@@ -0,0 +1,31 @@
+package pr2.exceptions.fakultaet.test;
+
+import org.junit.jupiter.api.Test;
+import pr2.exceptions.fakultaet.Fakultaet;
+import pr2.exceptions.fakultaet.FakultaetException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FakultaetTest {
+
+    @Test
+    void testFact() {
+        Fakultaet f = new Fakultaet();
+        assertEquals(1, f.fact(0));
+        assertEquals(1, f.fact(1));
+        assertEquals(2, f.fact(2));
+        assertEquals(6, f.fact(3));
+        assertEquals(24, f.fact(4));
+        assertEquals(3628800, f.fact(10));
+    }
+
+    @Test
+    void testFactEx1() {
+        // TODO: Auf Ausnahme testen
+    }
+
+    @Test
+    void testFactEx2() {
+        // TODO: Auf Ausnahme testen
+    }
+}

sources/src/main/java/pr2/exceptions/handle_or_declare/Buchstabenzaehler.java

@@ -0,0 +1,100 @@
+package pr2.exceptions.handle_or_declare;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Scanner;
+
+/**
+ * Anwendung, die die Buchstabenhäufigkeit in einem Text analysiert.
+ */
+public class Buchstabenzaehler {
+
+    /**
+     * Einstiegspunkt in das Programm.
+     *
+     * @param args Kommandozeilenargumente
+     */
+    public static void main(String[] args) {
+        Buchstabenzaehler bs = new Buchstabenzaehler();
+    }
+
+    /**
+     * Startet den Buchstabenzaehler.
+     *
+     * @throws StatistikException Fehler bei der Berechnung der
+     *                            Buchstabenhäufigkeit.
+     */
+    private void run() {
+        System.out.print("Bitte geben Sie den Dateinamen an: ");
+        Scanner scanner = new Scanner(System.in);
+        String dateiname = scanner.nextLine();
+
+        int[] statistik;
+
+    }
+
+    /**
+     * Druckt die Statistik aus.
+     *
+     * @param statistik Statistik
+     * @throws StatistikException Fehler bei den Eingabedaten
+     */
+    private void printStatistik(int[] statistik) {
+
+//        int summe = 0;
+//
+//        for (int haeufigkeit : statistik) {
+//            summe += haeufigkeit;
+//        }
+//
+//        double prozentSumme = 0.0;
+//
+//        for (char c = 'a'; c <= 'z'; c++) {
+//            int anzahl = statistik[c - 'a'];
+//            double prozent = (double) anzahl / (double) summe * 100;
+//            System.out.printf("%s: %.2f%% %n", "" + c, prozent);
+//
+//            prozentSumme += prozent;
+//        }
+//
+//        if ((prozentSumme < 99.0) || (prozentSumme > 101.0)) {
+//            throw new StatistikException(Double.toString(prozentSumme));
+//        }
+//
+//        System.out.printf("Summe: %.2f%% %n", prozentSumme);
+    }
+
+    /**
+     * Analysiert die übergebene Datei und berechnet die Buchstabenhäufigkeit.
+     *
+     * @param filename Dateiname
+     * @return die Buchstabenhäufigkeit. Das 'a' ist das erste Element,
+     *         das 'b' das zweite etc.
+     * @throws IOException           generelles IO-Problem
+     * @throws FileNotFoundException Datei gibt es nicht
+     */
+    private int[] parseFile(String filename) {
+
+        int[] statistik = new int['z' - 'a' + 1];
+
+//        BufferedReader br = new BufferedReader(new FileReader(filename));
+//
+//        String line;
+//
+//        while ((line = br.readLine()) != null) {
+//            char[] chars = line.toLowerCase().toCharArray();
+//
+//            for (char c : chars) {
+//                if (('a' <= c) && (c <= 'z')) {
+//                    statistik[c - 'a']++;
+//                }
+//            }
+//        }
+//
+//        br.close();
+
+        return statistik;
+    }
+}

sources/src/main/java/pr2/exceptions/handle_or_declare/StatistikException.java

@@ -0,0 +1,31 @@
+package pr2.exceptions.handle_or_declare;
+
+/**
+ * Ausnahme, wenn die Statisitk nicht konsistent ist.
+ */
+public class StatistikException extends Exception {
+
+    /**
+     * Legt eine neue Ausnahme an.
+     */
+    public StatistikException() {
+        super();
+    }
+
+    /**
+     * Legt eine neue Ausnahme an.
+     *
+     * @param message die Nachricht.
+     */
+    public StatistikException(String message) {
+        super(message);
+    }
+
+    /**
+     * @see java.lang.Throwable#toString()
+     */
+    @Override
+    public String toString() {
+        return getMessage();
+    }
+}

sources/src/main/java/pr2/exceptions/try_catch/Zahlenraten.java

@@ -0,0 +1,55 @@
+package pr2.exceptions.try_catch;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Random;
+
+/**
+ * Ein simples Zahlenraten-Spiel.
+ */
+public final class Zahlenraten {
+
+    /**
+     * Liest einen String von der Tastatur.
+     *
+     * @return der gelesene String
+     * @throws IOException Probleme mit der Console
+     */
+    private static String readNumber() throws IOException {
+        BufferedReader br =
+                new BufferedReader(new InputStreamReader(System.in));
+        return br.readLine();
+    }
+
+    /**
+     * Hauptmethode.
+     *
+     * @param args Kommandozeilenargumente
+     */
+    public static void main(String[] args)
+            throws NumberFormatException, IOException {
+
+        // zu ratende Zahl bestimmen
+        int zahl = new Random().nextInt(100) + 1;
+
+        int versuche = 0;
+
+        while (true) {
+            System.out.print("Bitte geben Sie eine Zahl ein: ");
+            int geraten  = Integer.parseInt(readNumber());
+            versuche++;
+
+            if (geraten < zahl) {
+                System.out.println("Zu niedrig");
+            }
+            else if (geraten > zahl) {
+                System.out.println("Zu hoch.");
+            }
+            else {
+                System.out.printf("Richtig in %d Versuchen", versuche);
+                break;
+            }
+        }
+    }
+}