+ * 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. + *
+ * Dasselbe gilt für die Entschlüsselung. Auch hier dürfen nur gültige + * Zeichen auftauchen. Andernfalls kommt es zu einer Ausnahme. + *
+ * 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. + *
+ * Zwischen den beiden Methoden muss bei gleichem Schlüssel {@code key} + * folgendes gelten: + *
+ * {@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); + } +} diff --git a/sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalKeyException.java b/sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalKeyException.java new file mode 100644 index 0000000..469e5bf --- /dev/null +++ b/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(); + } +} diff --git a/sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalMessageException.java b/sources/src/main/java/pr2/exceptions/ausnahmen_testen/IllegalMessageException.java new file mode 100644 index 0000000..141a2b7 --- /dev/null +++ b/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(); + } +} diff --git a/sources/src/main/java/pr2/exceptions/ausnahmen_testen/test/CaesarTest.java b/sources/src/main/java/pr2/exceptions/ausnahmen_testen/test/CaesarTest.java new file mode 100644 index 0000000..a821a0b --- /dev/null +++ b/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)); + } +} diff --git a/sources/src/main/java/pr2/exceptions/eigene_ausnahme/Fuse.java b/sources/src/main/java/pr2/exceptions/eigene_ausnahme/Fuse.java new file mode 100644 index 0000000..005ba13 --- /dev/null +++ b/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 + } +} diff --git a/sources/src/main/java/pr2/exceptions/eigene_ausnahme/FuseTrippedException.java b/sources/src/main/java/pr2/exceptions/eigene_ausnahme/FuseTrippedException.java new file mode 100644 index 0000000..d806156 --- /dev/null +++ b/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 +} diff --git a/sources/src/main/java/pr2/exceptions/eigene_ausnahme/IllegalCurrentException.java b/sources/src/main/java/pr2/exceptions/eigene_ausnahme/IllegalCurrentException.java new file mode 100644 index 0000000..6c9d99f --- /dev/null +++ b/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. +} diff --git a/sources/src/main/java/pr2/exceptions/eigene_ausnahme/test/FuseTest.java b/sources/src/main/java/pr2/exceptions/eigene_ausnahme/test/FuseTest.java new file mode 100644 index 0000000..2495370 --- /dev/null +++ b/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); +// }); +// } +} diff --git a/sources/src/main/java/pr2/exceptions/fakultaet/Fakultaet.java b/sources/src/main/java/pr2/exceptions/fakultaet/Fakultaet.java new file mode 100644 index 0000000..b711aea --- /dev/null +++ b/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; + } +} diff --git a/sources/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java b/sources/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java new file mode 100644 index 0000000..76819fe --- /dev/null +++ b/sources/src/main/java/pr2/exceptions/fakultaet/FakultaetException.java @@ -0,0 +1,5 @@ +package pr2.exceptions.fakultaet; + + public class FakultaetException { + +} diff --git a/sources/src/main/java/pr2/exceptions/fakultaet/test/FakultaetTest.java b/sources/src/main/java/pr2/exceptions/fakultaet/test/FakultaetTest.java new file mode 100644 index 0000000..a4745c3 --- /dev/null +++ b/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 + } +} diff --git a/sources/src/main/java/pr2/exceptions/handle_or_declare/Buchstabenzaehler.java b/sources/src/main/java/pr2/exceptions/handle_or_declare/Buchstabenzaehler.java new file mode 100644 index 0000000..30bc430 --- /dev/null +++ b/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; + } +} diff --git a/sources/src/main/java/pr2/exceptions/handle_or_declare/StatistikException.java b/sources/src/main/java/pr2/exceptions/handle_or_declare/StatistikException.java new file mode 100644 index 0000000..0d83170 --- /dev/null +++ b/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(); + } +} diff --git a/sources/src/main/java/pr2/exceptions/try_catch/Zahlenraten.java b/sources/src/main/java/pr2/exceptions/try_catch/Zahlenraten.java new file mode 100644 index 0000000..be31207 --- /dev/null +++ b/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; + } + } + } +}