2210892
/
uebungen
1
0
Fork 0
Code Issues Pull Requests 4 Packages Projects Releases Wiki Activity

Update of exercises

pull/12/head
Thomas Smits 2023-04-27 21:52:02 +02:00
parent 94b99d163b
commit 8e2d5db684
20 changed files with 917 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
Assignment_043/readme.md 100644
View File

@ -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`.

33
Assignment_044/readme.md 100644
View File

@ -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`.

25
Assignment_045/readme.md 100644
View File

@ -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`.

30
Assignment_046/readme.md 100644
View File

@ -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`.

29
Assignment_047/readme.md 100644
View File

@ -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`.

93
readme.md
View File

@ -6,47 +6,52 @@ 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) |
| 4. | 14.03.2023 | [printf mit Formatstring](Assignment_004/readme.md) |
| 5. | 14.03.2023 | [Maximum in einem Array suchen](Assignment_005/readme.md) |
| 6. | 14.03.2023 | [Taschenrechner](Assignment_006/readme.md) |
| 7. | 14.03.2023 | [Quine](Assignment_007/readme.md) |
| 8. | 20.03.2023 | [Java-Coding-Standard anwenden](Assignment_008/readme.md) |
| 9. | 20.03.2023 | [JavaDoc schreiben](Assignment_009/readme.md) |
| 10. | 20.03.2023 | [Klasse mit JUnit testen](Assignment_010/readme.md) |
| 11. | 20.03.2023 | [Information-Hiding einer Klasse verbessern](Assignment_011/readme.md) |
| 12. | 20.03.2023 | [Vorhandene Bibliotheken als JAR einbinden](Assignment_012/readme.md) |
| 13. | 24.03.2023 | [Final anwenden](Assignment_013/readme.md) |
| 14. | 24.03.2023 | [Figur und Rechteck](Assignment_014/readme.md) |
| 15. | 24.03.2023 | [Figur erweitern](Assignment_015/readme.md) |
| 16. | 24.03.2023 | [Figur noch einmal erweitern](Assignment_016/readme.md) |
| 17. | 24.03.2023 | [Konstruktoren schreiben](Assignment_017/readme.md) |
| 18. | 24.03.2023 | [Polymorphie einsetzen](Assignment_018/readme.md) |
| 19. | 24.03.2023 | [Singleton](Assignment_019/readme.md) |
| 20. | 24.03.2023 | [Statische Methoden und Attribute](Assignment_020/readme.md) |
| 21. | 24.03.2023 | [Methode überladen](Assignment_021/readme.md) |
| 22. | 24.03.2023 | [Methoden überschreiben](Assignment_022/readme.md) |
| 23. | 24.03.2023 | [Varag-Methode schreiben](Assignment_023/readme.md) |
| 24. | 24.03.2023 | [Vererbung von Figuren](Assignment_024/readme.md) |
| 25. | 11.04.2023 | [Abstrakte Klassen](Assignment_025/readme.md) |
| 26. | 11.04.2023 | [Abstrakte Klasse](Assignment_026/readme.md) |
| 27. | 11.04.2023 | [Comparable implementieren](Assignment_027/readme.md) |
| 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) |
| # | 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) |
| 4. | 14.03.2023 | [printf mit Formatstring](Assignment_004/readme.md) |
| 5. | 14.03.2023 | [Maximum in einem Array suchen](Assignment_005/readme.md) |
| 6. | 14.03.2023 | [Taschenrechner](Assignment_006/readme.md) |
| 7. | 14.03.2023 | [Quine](Assignment_007/readme.md) |
| 8. | 20.03.2023 | [Java-Coding-Standard anwenden](Assignment_008/readme.md) |
| 9. | 20.03.2023 | [JavaDoc schreiben](Assignment_009/readme.md) |
| 10. | 20.03.2023 | [Klasse mit JUnit testen](Assignment_010/readme.md) |
| 11. | 20.03.2023 | [Information-Hiding einer Klasse verbessern](Assignment_011/readme.md) |
| 12. | 20.03.2023 | [Vorhandene Bibliotheken als JAR einbinden](Assignment_012/readme.md) |
| 13. | 24.03.2023 | [Final anwenden](Assignment_013/readme.md) |
| 14. | 24.03.2023 | [Figur und Rechteck](Assignment_014/readme.md) |
| 15. | 24.03.2023 | [Figur erweitern](Assignment_015/readme.md) |
| 16. | 24.03.2023 | [Figur noch einmal erweitern](Assignment_016/readme.md) |
| 17. | 24.03.2023 | [Konstruktoren schreiben](Assignment_017/readme.md) |
| 18. | 24.03.2023 | [Polymorphie einsetzen](Assignment_018/readme.md) |
| 19. | 24.03.2023 | [Singleton](Assignment_019/readme.md) |
| 20. | 24.03.2023 | [Statische Methoden und Attribute](Assignment_020/readme.md) |
| 21. | 24.03.2023 | [Methode überladen](Assignment_021/readme.md) |
| 22. | 24.03.2023 | [Methoden überschreiben](Assignment_022/readme.md) |
| 23. | 24.03.2023 | [Varag-Methode schreiben](Assignment_023/readme.md) |
| 24. | 24.03.2023 | [Vererbung von Figuren](Assignment_024/readme.md) |
| 25. | 11.04.2023 | [Abstrakte Klassen](Assignment_025/readme.md) |
| 26. | 11.04.2023 | [Abstrakte Klasse](Assignment_026/readme.md) |
| 27. | 11.04.2023 | [Comparable implementieren](Assignment_027/readme.md) |
| 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) |
| 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) |

164
sources/src/main/java/pr2/exceptions/ausnahmen_testen/CrypterCaesar.java 100644
View File

@ -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);
}
}

31
sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalKeyException.java 100644
View File

@ -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();
}
}

31
sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalMessageException.java 100644
View File

@ -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();
}
}

36
sources/src/main/java/pr2/exceptions/ausnahmen_testen/test/CaesarTest.java 100644
View File

@ -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));
}
}

49
sources/src/main/java/pr2/exceptions/eigene_ausnahme/Fuse.java 100644
View File

@ -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
}
}

9
sources/src/main/java/pr2/exceptions/eigene_ausnahme/FuseTrippedException.java 100644
View File

@ -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
}

9
sources/src/main/java/pr2/exceptions/eigene_ausnahme/IllegalCurrentException.java 100644
View File

@ -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.
}

159
sources/src/main/java/pr2/exceptions/eigene_ausnahme/test/FuseTest.java 100644
View File

@ -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);
// });
// }
}

12
sources/src/main/java/pr2/exceptions/fakultaet/Fakultaet.java 100644
View File

@ -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;
}
}

5
sources/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java 100644
View File

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

31
sources/src/main/java/pr2/exceptions/fakultaet/test/FakultaetTest.java 100644
View File

@ -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
}
}

100
sources/src/main/java/pr2/exceptions/handle_or_declare/Buchstabenzaehler.java 100644
View File

@ -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;
}
}

31
sources/src/main/java/pr2/exceptions/handle_or_declare/StatistikException.java 100644
View File

@ -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();
}
}

55
sources/src/main/java/pr2/exceptions/try_catch/Zahlenraten.java 100644
View File

@ -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;
}
}
}
}