From 899ee1ea64418fa893794338a8500d4411e2af9f Mon Sep 17 00:00:00 2001 From: Thomas Smits Date: Wed, 10 Jun 2026 14:22:56 +0200 Subject: [PATCH] Update of exercises --- Assignment_012/readme.md | 180 ++++++++++++++++++ readme.md | 5 +- .../main/java/pr2/collections/ip/Main.java | 16 ++ .../pr2/collections/ip/iputils/IPAddress.java | 78 ++++++++ .../collections/ip/iputils/IPFormatter.java | 9 + .../collections/ip/iputils/IPInformation.java | 20 ++ .../ip/iputils/IPParseException.java | 16 ++ .../pr2/collections/ip/iputils/IPParser.java | 8 + .../vererbung/password/rules/RuleFactory.java | 1 + .../pr2/vererbung/racewars/model/Wesen.java | 12 +- .../test/java/pr2/collections/ip/IPTest.java | 11 ++ 11 files changed, 343 insertions(+), 13 deletions(-) create mode 100644 Assignment_012/readme.md create mode 100644 sources/src/main/java/pr2/collections/ip/Main.java create mode 100644 sources/src/main/java/pr2/collections/ip/iputils/IPAddress.java create mode 100644 sources/src/main/java/pr2/collections/ip/iputils/IPFormatter.java create mode 100644 sources/src/main/java/pr2/collections/ip/iputils/IPInformation.java create mode 100644 sources/src/main/java/pr2/collections/ip/iputils/IPParseException.java create mode 100644 sources/src/main/java/pr2/collections/ip/iputils/IPParser.java create mode 100644 sources/src/test/java/pr2/collections/ip/IPTest.java diff --git a/Assignment_012/readme.md b/Assignment_012/readme.md new file mode 100644 index 0000000..cfaa1da --- /dev/null +++ b/Assignment_012/readme.md @@ -0,0 +1,180 @@ +# IP-Adressen + +**🎓 Benotetes Assignment 🎓** + +📆 **Fällig: 23.06.2026** 📆 + +Mittlerweile haben Sie sich mit den Aliens angefreundet. Allerdings müssen sie demnächst zurück nach Hause. + +"Es tut uns leid, aber mir müssen gehen" + +Sie wollen aber weiterhin mit Ihren neuen Freunden im Kontakt bleiben. + +"Müsst ihr wirklich gehen?" + +Dann schlugen die Aliens etwas vor: + +"Ja, aber wir können unsere Computer in einem Netzwerk verbinden, um weiterhin zu kommunizieren". + +Diese Idee klang super, bis Sie feststellten, dass sie nicht wissen, wie man +Computer in einem Netzwerk verbindet. + +"Aber wie soll das gehen?" + +"Wir brauchen dafür nur IP-Adressen im selben Netzwerk" + +Dafür brauchen Sie aber ein Tool, mit dem Sie IP-Adressen in einem Netzwerk +berechnen können. + +## Paket + +Gehen Sie in das Paket [pr2.collections.ip](../sources/src/main/java/pr2/collections/ip/). + +## Implementierung + +Im Paket +[pr2.collections.ip.iputils](../sources/src/main/java/pr2/collections/ip/iputils/) befinden sich folgende Inhalte: + + * `IPAdress` -> Eine Klasse + * `IPFormatter` -> Ein Interface + * `IPParser` -> Ein Interface + * `IPInformation` -> Ein Enum + * `IPParseException` -> Eine Ausnahme + +Und noch eine `Main` im darüberliegendem Paket. + +Zur Information über IP-Adressen: + + * Eine IP-Adresse besteht aus 2 Teilen: die Adresse selbst sowie die Subnetzmaske + * Die Subnetzmaske beginnt immer links, und eine Folge von 1 und danach nur noch 0. Zum Beispiel `11110000` wäre eine Subnetzmaske (nicht vollständig, geht um das Konzept), `10100001` aber nicht. + * Die Subnetzmaske wird üblicherweise mit `/X` angegeben, wo `X` die Anzahl an Bits ist, die auf 1 sind. + * Die Subnetzmaske ist immer genauso lang wie die IP-Adresse (in bytes) + * Die Netzwerkadresse wird berechnet, indem alle Host-Bits auf 0 gesetzt werden, bsp: `10101010` als IP und `11110000` als Subnetzmaske ergeben `10100000` als Netzwerkadresse. + * Die Broadcastadresse wird berechnet, indem alle Host-Bits auf 1 gesetzt werden, bsp: `10101010` als IP und `11110000` als Subnetzmaske ergeben `10101111` als Broadcastadresse. + +### `Main` + +Diese Klasse hat eine `main`-Methode, welche den Nutzer auf der Konsole nach einer IP-Adresse frägt, diese einliest, verarbeitet und dann das Ergebnis auf der Konsole ausgibt. Ein Beispiel könnte wie folgt aussehen: + +``` +Bitte gib eine IP-Adresse ein: 192.168.0.1/30 +``` + +``` +IP-Adresse: 192.168.0.1/30 +Network: 192.168.0.0/30 +Broadcast: 192.168.0.3/30 +Range: 192.168.0.1/30 - 192.168.0.2/30 +Verfügbare Adressen: +192.168.0.1/30 +192.168.0.2/30 +``` + +Sie dürfen gerne beliebig rumspielen, aber eine simple Ausgabe wie im obigen Beispiel genügt. + +### `IPAddress` + +Dieser Klasse fehlt einiges: + + * `getNetworkAddress` Implementierung + * `getBroadcastAddress` Implementierung + * `addHostByte` Implementierung + * `prettyFormat` Implementierung + * `iterator` Implementierung + * Konstruktoren + +In den Javadocs können Sie sehen, was die Methoden jeweils tun sollen. Es soll neben dem Copy-Konstruktor auch einen Konstruktor geben, der eine **verarbeitbare Darstellung einer IP-Adresse** sowie einen passenden `IPFormatter` bekommt. + +Überlegen Sie sich gut, wie eine **verarbeitbare Darstellung einer IP-Adresse** aussehen sollte. + +Dann zum Iterator: dieser soll über die IP-Adressen im Range iterieren, sprich die _Netzwerkadresse_ sowie die _Broadcastadresse_ **nicht** mit einbegriffen. Sie dürfen eine Innere-Klasse oder seperate Klasse verwenden, beide sollen allerdings von außen nicht sichtbar sein! + +Dann noch ein Beispiel-Output für die `prettyFormat`-Methode: + +``` +IP-Adresse: 192.168.0.1/30 +Network: 192.168.0.0/30 +Broadcast: 192.168.0.3/30 +Range: 192.168.0.1/30 - 192.168.0.2/30 +Verfügbare Adressen: +192.168.0.1/30 +192.168.0.2/30 +``` + +### `IPFormatter` + +Diesem Interface fehlt noch eine Methode `format`. Diese Methode soll einen String als Rückgabewert zurückgeben. Überlegen Sie sich geeignete Parameter. + +### `IPParser` + +Diesem Interface fehlt noch eine Methode `parse`. Diese Methode soll einen String übergeben bekommen und eine für die `IPAddress` **verarbeitbare Darstellung der IP-Adresse** zurückgeben. Überlegen Sie sich einen geeigneten Rückgabewert. + +### `IPInformation` + +Dieses Enum soll Optionen für das `prettyFormat` der `IPAddress` angeben. Sie dürfen hier auch gerne Methoden hinzufügen, es dürfen aber **keine** Konsolen-Ausgaben getätig werden. + +Es sollte für folgendes Optionen geben: + + * Die IP-Adresse + * Die Netzwerkadresse der IP-Adresse + * Die Broadcast-Adresse der IP-Adresse + * Den Range der IP-Adresse (**Netzwerkadresse+1** - **Broadcastadresse-1**) + * Alle IP-Adressen im Range ausgeben + +### `IPParseException` + +Diese Klasse ist bereits implementiert. Sie dürfen diese gerne ändern, müssen dies aber nicht. + +### Weiteres + +Ebenfalls fehlt jeweils eine Klasse, die `IPFormatter` bzw. `IPParser` implementieren. Erstellen Sie dafür entsprechend eine `IPv4Formatter` und `IPv4Parser` Klasse und implementieren Sie diese. Es sollen gängige IPv4-Adressen verarbeitbar / ausgegeben werden können, zum Beispiel `192.168.0.1/24`. + +### Bonus [+25 Punkte] + +Wer Bonus-Punkte möchte, darf zusätzlich einen `IPv6Formatter` und `IPv6Parser` erstellen und implementieren. Die Punkte gibt es allerdings **nur**, wenn alle folgende Formate sowohl eingegeben als auch ausgegeben werden können: + + * `::/24` + * `::1/24` + * `1::1/24` + * `1:1::1/24` + * `1111:1111:1111:1111:1111:1111:1111:1111/24` + +**Informationen** + + * Das sind nur Beispiele für die Formate, natürlich sollten alle möglichen IPv6-Adressen in diesen Formaten funktionieren. + * Es sollte **keine** andere Klasse angepasst werden, dass IPv6 funktioniert, mit Ausnahme der `Main` + +Und natürlich soll das ganze dann auch in der `Main` funktionieren, zum Beispiel: + +``` +Bitte gebe eine IP-Adresse ein: ::1/126 +IP-Adresse: ::1/126 +Network: ::/126 +Broadcast: ::3/126 +Range: ::1/126 - ::2/126 +Verfügbare Adressen: +::1/126 +::2/126 +``` + +## Tests + +Überprüfen Sie die Funktionalität Ihrer Implementierung mit entsprechenden JUnit-Tests und weisen Sie mit diesen Tests nach, dass die implementierten Operationen richtig funktionieren. Testen Sie alle Methoden und Konstruktoren (die `prettyFormat`-Methode müssen Sie nicht testen). + +**Abgabe**: Source-Code der Tests als `IPTest`. + + +## Abgabe + +Alle Abgaben für die Vorlesung erfolgen über `git` und das Ihnen zugeordnete Repository. + +Hierzu gehen Sie wie folgt vor: + + 1. Öffnen Sie eine Kommandozeile (Terminal). + 2. Gehen Sie in Ihr Working Directory. + 3. Rufen Sie mit `bin/submit.sh` das Skript auf, das die Lösungen testet und kompiliert. Wenn Maven eine Fehlermeldung zeigt, beheben Sie diese zuerst, bevor Sie mit dem nächsten Schritt fortfahren. + 4. Wenn Sie Meldung "✅ Projekt gebaut" bekommen, checken Sie Ihre Änderungen in `git` **auf der Kommandozeile** ein (comitten), d.h. mit `git add` und `git commit`. Verwenden Sie **nicht** Eclipse für diesen Schritt. + 5. Rufen Sie mit `bin/submit.sh` erneut das Skript auf. Wenn alles klappt, bekommen Sie die Anzeige "✅ Aktuelle Lösungen eingereicht" und Ihre Lösung ist im System angekommen. + 6. Überprüfen Sie über das Web-Frontend, ob alles so im Repository liegt, wie Sie es erwarten. + +**Erinnerung**: Denken Sie daran, dass Sie alle **öffentlichen Methoden** mit entsprechender **Javadoc** versehen müssen. **Ausgaben** auf und **Eingaben** von der Konsole sind nur dann erlaubt, wenn der Aufgabentext es explizit verlangt. \ No newline at end of file diff --git a/readme.md b/readme.md index c02abd8..c795909 100644 --- a/readme.md +++ b/readme.md @@ -28,6 +28,7 @@ Wichtige Einstellungen für Eclipse sind [hier](help/eclipse.md) beschrieben. | 9. | 06.05.2026 | [Was hoppelt den da?](Assignment_009/readme.md) | **19.05.2026** | | 10. | 13.05.2026 | [Live-Testat](Assignment_010/readme.md) | **13.05.2026** | | 11. | 20.05.2026 | [Mist die Festplatte ist schon wieder voll](Assignment_011/readme.md) | **09.06.2026** | +| 12. | 10.06.2026 | [IP-Adressen](Assignment_012/readme.md) | **23.06.2026** | ## 🏛️ Aufbau der Veranstaltung @@ -45,8 +46,8 @@ Die folgende Tabelle zeigt Ihnen die Themen der Woche und welche Kapitel Sie bis | 8 | Wenn es mal schief geht, Ausnahmen | Exceptions, try, catch | [9][9] | [1][as_001], [2][as_002], [3][as_003], [4][as_004], [5][as_005] | **04.05** | | 9 | Rein oder raus, die Daten müssen fließen | Input/Output mit Streams und Reader/Writer | [10][10] | [1][io_001], [2][io_002], [3][io_003], [4][io_004], [5][io_005], [6][io_006], [7][io_007], [8][io_008], [9][io_009], [10][io_010], [11][io_011], [12][io_012], [13][io_013], [14][io_014], [15][io_015], [16][io_016] | **11.05** | | 10 | One size fits all, mit generischen Typen | Generische Typen, Wildcards | [11][11] | [1][ge_001], [2][ge_002], [3][ge_003], [4][ge_004], [5][ge_005], [6][ge_006], [7][ge_007], [8][ge_008], [9][ge_009] | **18.05** | -| 11 | Matroschka-Klassen | Geschachtelte Klassen, Lambdas | [12][12] | [1][gk_001], [2][gk_002], [3][gk_003], [4][la_001], [5][la_002] | **01.06** | -| 12 | Daten brauchen Struktur | Abstrakte Datentypen | [13][13] | | **08.06** | +| 11 | Daten brauchen Struktur | Abstrakte Datentypen | [13][13] | | **01.06** | +| 11 | Matroschka-Klassen | Geschachtelte Klassen, Lambdas | [12][12] | [1][gk_001], [2][gk_002], [3][gk_003], [4][la_001], [5][la_002] | **08.06** | | 13 | Objekte sammeln | Collections und Streams | [14][14], [15][15] | [1][co_001], [2][co_002], [3][co_003], [4][co_004], [5][co_005], [6][co_006], [7][co_007], [8][co_008], [9][co_009], [10][co_010], [11][co_011], [12][sr_001], [13][sr_002], [14][sr_003], [15][sr_004], [16][sr_005], [17][sr_006], [18][sr_007], [19][sr_008], [20][sr_009], [21][sr_010] | **15.06** | | 14 | Parallel läuft es schneller | Threads, Probleme der Thread-Programmierung | [16][16] | [1][th_001], [2][th_002], [3][th_003], [4][th_004], [5][th_005], [6][th_006], [7][th_007], [8][th_008] | **22.06** | diff --git a/sources/src/main/java/pr2/collections/ip/Main.java b/sources/src/main/java/pr2/collections/ip/Main.java new file mode 100644 index 0000000..b647dd8 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/Main.java @@ -0,0 +1,16 @@ +package pr2.collections.ip; + + +/** + * Main-Klasse mit der main-Methode. + */ +public class Main { + + /** + * Die main-Methode für ein Konsoleninterface. + * + * @param args die Konsolen-Argumente. + */ + public static void main(String[] args) { + } +} diff --git a/sources/src/main/java/pr2/collections/ip/iputils/IPAddress.java b/sources/src/main/java/pr2/collections/ip/iputils/IPAddress.java new file mode 100644 index 0000000..3fdfc46 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/iputils/IPAddress.java @@ -0,0 +1,78 @@ +package pr2.collections.ip.iputils; + +import java.util.Set; +import java.util.Iterator; + +/** + * Eine Klasse um eine IP-Adresse zu repräsentieren und Berechnung + * auszuführen. + */ +public class IPAddress implements Iterable { + + /** + * Ein Copy-Konstruktor. + * + * @param ip die IP, von der eine Kopie erstellt werden soll. + */ + public IPAddress(IPAddress ip) { + } + + + + /** + * Berechnet die Netzwerkadresse und liefert diese als neues {@link IPAddress} + * Objekt zurück. + * + * @return die Netzwerkadresse. + */ + public IPAddress getNetworkAddress() { + return null; + } + + /** + * Berechnet die Broadcast-Adresse und liefer diese als neues {@link IPAddress} + * Objekt zurück. + * + * @return die Broadcast-Adresse. + */ + public IPAddress getBroadcastAddress() { + return null; + } + + /** + * Fügt den Host-Bits einen Wert hinzu und gibt die daraus folgende IP-Adresse + * als neues {@link IPAddress} Objekt zurück. Falls die neue Adresse über die + * Broadcast-Adresse geht, wird die Broadcast-Adresse zurückgegeben. Falls die + * neue Adresse unter die Netzwerkadresse geht, wird die Netzwerkadresse + * zurückgegeben. + * + * @param amount die Menge um wie viel sich die Host-Bits ändern sollen. + * @return die neue IP-Adresse. + */ + public IPAddress addHostByte(int amount) { + return null; + } + + @Override + public String toString() { + return null; + } + + + /** + * Gibt die {@link IPAddress} in einem schön formatierten {@link String} zurück. + * + * @param information welche informationen in der Rückgabe enthalten sein + * sollen. + * @return ein schön formatierter {@link String}. + */ + public String prettyFormat(Set information) { + return null; + } + + + @Override + public Iterator iterator() { + return null; + } +} diff --git a/sources/src/main/java/pr2/collections/ip/iputils/IPFormatter.java b/sources/src/main/java/pr2/collections/ip/iputils/IPFormatter.java new file mode 100644 index 0000000..148a291 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/iputils/IPFormatter.java @@ -0,0 +1,9 @@ +package pr2.collections.ip.iputils; + +/** + * Interface mit einer Methode um aus IP-Adress-Bytes einen String zu machen. + */ +public interface IPFormatter { + + +} diff --git a/sources/src/main/java/pr2/collections/ip/iputils/IPInformation.java b/sources/src/main/java/pr2/collections/ip/iputils/IPInformation.java new file mode 100644 index 0000000..e54dc13 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/iputils/IPInformation.java @@ -0,0 +1,20 @@ +package pr2.collections.ip.iputils; + +/** + * Enum mit pretty-print Optionen. + */ +public enum IPInformation { + + REPLACEME; + + /** + * Formatiert eine {@link IPAddress} zur gegebenen Option. + * + * @param ip die {@link IPAddress} zum Formatieren. + * @return der formatierte String. + */ + public String toString(IPAddress ip) { + return null; + } + +} diff --git a/sources/src/main/java/pr2/collections/ip/iputils/IPParseException.java b/sources/src/main/java/pr2/collections/ip/iputils/IPParseException.java new file mode 100644 index 0000000..00f5839 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/iputils/IPParseException.java @@ -0,0 +1,16 @@ +package pr2.collections.ip.iputils; + +/** + * Wird geworfen, wenn eine IP-Adresse nicht verarbeitet werden konnte. + */ +public class IPParseException extends Exception { + /** + * Konstruktor für die Ausnahme. + * + * @param version die IP-Version. + * @param text die Fehlermeldung. + */ + public IPParseException(int version, String text) { + super(String.format("Failed to parse IPv%d: %s.", version, text)); + } +} diff --git a/sources/src/main/java/pr2/collections/ip/iputils/IPParser.java b/sources/src/main/java/pr2/collections/ip/iputils/IPParser.java new file mode 100644 index 0000000..55d47f6 --- /dev/null +++ b/sources/src/main/java/pr2/collections/ip/iputils/IPParser.java @@ -0,0 +1,8 @@ +package pr2.collections.ip.iputils; + +/** + * Interface mit einer Methode um aus einem String eine verarbeitbare + * Repräsentation für eine IP-Adresse zu generieren. + */ +public interface IPParser { +} diff --git a/sources/src/main/java/pr2/vererbung/password/rules/RuleFactory.java b/sources/src/main/java/pr2/vererbung/password/rules/RuleFactory.java index 14f629f..6e8cc0b 100644 --- a/sources/src/main/java/pr2/vererbung/password/rules/RuleFactory.java +++ b/sources/src/main/java/pr2/vererbung/password/rules/RuleFactory.java @@ -43,5 +43,6 @@ public class RuleFactory { public static Rule createRule(int number) { // TODO: Hier sollten sich Ihre Änderungen abspielen + return null; } } diff --git a/sources/src/main/java/pr2/vererbung/racewars/model/Wesen.java b/sources/src/main/java/pr2/vererbung/racewars/model/Wesen.java index eda38e6..de31e82 100644 --- a/sources/src/main/java/pr2/vererbung/racewars/model/Wesen.java +++ b/sources/src/main/java/pr2/vererbung/racewars/model/Wesen.java @@ -3,17 +3,7 @@ package pr2.vererbung.racewars.model; /** * Basisklasse für alle Wesen im Spiel. */ -public abstract class Wesen implements Angreifer, Angegriffener { +public abstract class Wesen { - /** - * Greife das andere Wesen an. Der Schaden wird berechnet und beim - * gegnerischen Wesen abgezogen. - * - * @param gegner Wesen, das angegriffen werden soll. - * @return Zugefügter Schaden. - */ - @Override - public abstract double attacke(Angegriffener gegner); - } diff --git a/sources/src/test/java/pr2/collections/ip/IPTest.java b/sources/src/test/java/pr2/collections/ip/IPTest.java new file mode 100644 index 0000000..9434f47 --- /dev/null +++ b/sources/src/test/java/pr2/collections/ip/IPTest.java @@ -0,0 +1,11 @@ +package pr2.collections.ip; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import pr2.collections.ip.iputils.*; + +import static org.junit.jupiter.api.Assertions.*; + +public class IPTest { +}