From 86415254cb59d760fe18d529410bdea12c1f8c2b Mon Sep 17 00:00:00 2001 From: Thomas Smits Date: Wed, 27 Nov 2024 14:28:12 +0100 Subject: [PATCH] Update of exercises --- Generische_Typen_001/readme.md | 2 +- Generische_Typen_001/solution/readme.md | 5 + Generische_Typen_002/readme.md | 2 +- Generische_Typen_002/solution/readme.md | 5 + Generische_Typen_003/readme.md | 2 +- Generische_Typen_003/solution/readme.md | 5 + Generische_Typen_004/readme.md | 2 +- Generische_Typen_004/solution/readme.md | 5 + Generische_Typen_005/readme.md | 2 +- Generische_Typen_005/solution/readme.md | 5 + Generische_Typen_006/readme.md | 2 +- Generische_Typen_006/solution/readme.md | 5 + Generische_Typen_007/readme.md | 2 +- Generische_Typen_007/solution/readme.md | 5 + Generische_Typen_008/readme.md | 2 +- Generische_Typen_008/solution/readme.md | 5 + Generische_Typen_009/readme.md | 2 +- Generische_Typen_009/solution/readme.md | 5 + readme.md | 18 +-- .../main/java/pr2/generics/einfach/Liste.java | 90 +++++++++++++++ .../java/pr2/generics/einfach/ListeNode.java | 30 +++++ .../pr2/generics/einfach/test/ListeTest.java | 61 ++++++++++ .../java/pr2/generics/number_pair/Main.java | 15 +++ .../pr2/generics/number_pair/NumberPair.java | 8 ++ .../java/pr2/generics/number_pair/Pair.java | 20 ++++ .../src/main/java/pr2/generics/pair/Main.java | 17 +++ .../src/main/java/pr2/generics/pair/Pair.java | 20 ++++ .../main/java/pr2/generics/pairlist/Main.java | 19 +++ .../main/java/pr2/generics/pairlist/Pair.java | 20 ++++ .../java/pr2/generics/pairlist/PairList.java | 20 ++++ .../generics/printer/CollectionPrinter.java | 11 ++ .../main/java/pr2/generics/printer/Main.java | 23 ++++ .../main/java/pr2/generics/queue/Queue.java | 39 +++++++ .../java/pr2/generics/same_pair/Main.java | 15 +++ .../java/pr2/generics/same_pair/Pair.java | 20 ++++ .../java/pr2/generics/same_pair/SamePair.java | 8 ++ .../pr2/generics/super_extends/Liste.java | 108 ++++++++++++++++++ .../pr2/generics/super_extends/ListeNode.java | 28 +++++ .../super_extends/test/ListeTest.java | 42 +++++++ .../pr2/generics/wildcards/ListHelper.java | 35 ++++++ .../java/pr2/generics/wildcards/Main.java | 39 +++++++ .../pr2/generics/wildcards/SimpleList.java | 12 ++ 42 files changed, 763 insertions(+), 18 deletions(-) create mode 100644 Generische_Typen_001/solution/readme.md create mode 100644 Generische_Typen_002/solution/readme.md create mode 100644 Generische_Typen_003/solution/readme.md create mode 100644 Generische_Typen_004/solution/readme.md create mode 100644 Generische_Typen_005/solution/readme.md create mode 100644 Generische_Typen_006/solution/readme.md create mode 100644 Generische_Typen_007/solution/readme.md create mode 100644 Generische_Typen_008/solution/readme.md create mode 100644 Generische_Typen_009/solution/readme.md create mode 100644 solutions/src/main/java/pr2/generics/einfach/Liste.java create mode 100644 solutions/src/main/java/pr2/generics/einfach/ListeNode.java create mode 100644 solutions/src/main/java/pr2/generics/einfach/test/ListeTest.java create mode 100644 solutions/src/main/java/pr2/generics/number_pair/Main.java create mode 100644 solutions/src/main/java/pr2/generics/number_pair/NumberPair.java create mode 100644 solutions/src/main/java/pr2/generics/number_pair/Pair.java create mode 100644 solutions/src/main/java/pr2/generics/pair/Main.java create mode 100644 solutions/src/main/java/pr2/generics/pair/Pair.java create mode 100644 solutions/src/main/java/pr2/generics/pairlist/Main.java create mode 100644 solutions/src/main/java/pr2/generics/pairlist/Pair.java create mode 100644 solutions/src/main/java/pr2/generics/pairlist/PairList.java create mode 100644 solutions/src/main/java/pr2/generics/printer/CollectionPrinter.java create mode 100644 solutions/src/main/java/pr2/generics/printer/Main.java create mode 100644 solutions/src/main/java/pr2/generics/queue/Queue.java create mode 100644 solutions/src/main/java/pr2/generics/same_pair/Main.java create mode 100644 solutions/src/main/java/pr2/generics/same_pair/Pair.java create mode 100644 solutions/src/main/java/pr2/generics/same_pair/SamePair.java create mode 100644 solutions/src/main/java/pr2/generics/super_extends/Liste.java create mode 100644 solutions/src/main/java/pr2/generics/super_extends/ListeNode.java create mode 100644 solutions/src/main/java/pr2/generics/super_extends/test/ListeTest.java create mode 100644 solutions/src/main/java/pr2/generics/wildcards/ListHelper.java create mode 100644 solutions/src/main/java/pr2/generics/wildcards/Main.java create mode 100644 solutions/src/main/java/pr2/generics/wildcards/SimpleList.java diff --git a/Generische_Typen_001/readme.md b/Generische_Typen_001/readme.md index 73d89a5..8fa3cd7 100644 --- a/Generische_Typen_001/readme.md +++ b/Generische_Typen_001/readme.md @@ -1,6 +1,6 @@ # Einen generischen Typ schreiben ## Lernziel - + [Musterlösung](solution/) Einen vorhandenen Typ so umgestalten, dass er als generischer Typ verwendet werden kann. diff --git a/Generische_Typen_001/solution/readme.md b/Generische_Typen_001/solution/readme.md new file mode 100644 index 0000000..1a645c1 --- /dev/null +++ b/Generische_Typen_001/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Einen generischen Typ schreiben + +Musterlösung: + +[pr2.generics.einfach](../../solutions/src/main/java/pr2/generics/einfach/) diff --git a/Generische_Typen_002/readme.md b/Generische_Typen_002/readme.md index 79da9ec..fa9ab2d 100644 --- a/Generische_Typen_002/readme.md +++ b/Generische_Typen_002/readme.md @@ -1,6 +1,6 @@ # Generische Klasse Pair schreiben ## Lernziel - + [Musterlösung](solution/) Von einem generischen Typ erben. diff --git a/Generische_Typen_002/solution/readme.md b/Generische_Typen_002/solution/readme.md new file mode 100644 index 0000000..e4303a8 --- /dev/null +++ b/Generische_Typen_002/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Generische Klasse Pair schreiben + +Musterlösung: + +[pr2.generics.pair](../../solutions/src/main/java/pr2/generics/pair/) diff --git a/Generische_Typen_003/readme.md b/Generische_Typen_003/readme.md index 682e5e1..f4edfcd 100644 --- a/Generische_Typen_003/readme.md +++ b/Generische_Typen_003/readme.md @@ -1,6 +1,6 @@ # Generische Klasse Pair erweitern: NumberPair ## Lernziel - + [Musterlösung](solution/) Von einem generischen Typ erben. diff --git a/Generische_Typen_003/solution/readme.md b/Generische_Typen_003/solution/readme.md new file mode 100644 index 0000000..da73c86 --- /dev/null +++ b/Generische_Typen_003/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Generische Klasse Pair erweitern: NumberPair + +Musterlösung: + +[pr2.generics.number_pair](../../solutions/src/main/java/pr2/generics/number_pair/) diff --git a/Generische_Typen_004/readme.md b/Generische_Typen_004/readme.md index 4ae6226..796bca0 100644 --- a/Generische_Typen_004/readme.md +++ b/Generische_Typen_004/readme.md @@ -1,6 +1,6 @@ # Generische Klasse Pair erweitern: SamePair ## Lernziel - + [Musterlösung](solution/) Von einem generischen Typ erben. diff --git a/Generische_Typen_004/solution/readme.md b/Generische_Typen_004/solution/readme.md new file mode 100644 index 0000000..a8c9b5c --- /dev/null +++ b/Generische_Typen_004/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Generische Klasse Pair erweitern: SamePair + +Musterlösung: + +[pr2.generics.same_pair](../../solutions/src/main/java/pr2/generics/same_pair/) diff --git a/Generische_Typen_005/readme.md b/Generische_Typen_005/readme.md index 55a9b8f..232d90b 100644 --- a/Generische_Typen_005/readme.md +++ b/Generische_Typen_005/readme.md @@ -1,6 +1,6 @@ # PairList ## Lernziel - + [Musterlösung](solution/) Sammlungen von Objekten eines generischen Typs erstellen. diff --git a/Generische_Typen_005/solution/readme.md b/Generische_Typen_005/solution/readme.md new file mode 100644 index 0000000..7a66bc8 --- /dev/null +++ b/Generische_Typen_005/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: PairList + +Musterlösung: + +[pr2.generics.pairlist](../../solutions/src/main/java/pr2/generics/pairlist/) diff --git a/Generische_Typen_006/readme.md b/Generische_Typen_006/readme.md index 4cbb3db..c022b93 100644 --- a/Generische_Typen_006/readme.md +++ b/Generische_Typen_006/readme.md @@ -1,6 +1,6 @@ # Wildcard benutzen ## Lernziel - + [Musterlösung](solution/) Wildcards einsetzen. diff --git a/Generische_Typen_006/solution/readme.md b/Generische_Typen_006/solution/readme.md new file mode 100644 index 0000000..510b1f5 --- /dev/null +++ b/Generische_Typen_006/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Wildcard benutzen + +Musterlösung: + +[pr2.generics.printer](../../solutions/src/main/java/pr2/generics/printer/) diff --git a/Generische_Typen_007/readme.md b/Generische_Typen_007/readme.md index d14fccf..674f811 100644 --- a/Generische_Typen_007/readme.md +++ b/Generische_Typen_007/readme.md @@ -1,6 +1,6 @@ # Generische Queue ## Lernziel - + [Musterlösung](solution/) Einen komplexeren generischen Typ entwickeln. diff --git a/Generische_Typen_007/solution/readme.md b/Generische_Typen_007/solution/readme.md new file mode 100644 index 0000000..68a84e8 --- /dev/null +++ b/Generische_Typen_007/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Generische Queue + +Musterlösung: + +[pr2.generics.queue](../../solutions/src/main/java/pr2/generics/queue/) diff --git a/Generische_Typen_008/readme.md b/Generische_Typen_008/readme.md index 89d585d..90c6490 100644 --- a/Generische_Typen_008/readme.md +++ b/Generische_Typen_008/readme.md @@ -1,6 +1,6 @@ # `super` und `extends` einsetzen ## Lernziel - + [Musterlösung](solution/) Methoden unter Verwendung von `super` und `extends` gestalten, sodass sie flexibel auch mit Sub- bzw. Supertypen umgehen können. diff --git a/Generische_Typen_008/solution/readme.md b/Generische_Typen_008/solution/readme.md new file mode 100644 index 0000000..6321f6a --- /dev/null +++ b/Generische_Typen_008/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: `super` und `extends` einsetzen + +Musterlösung: + +[pr2.generics.super_extends](../../solutions/src/main/java/pr2/generics/super_extends/) diff --git a/Generische_Typen_009/readme.md b/Generische_Typen_009/readme.md index d936508..ac06be2 100644 --- a/Generische_Typen_009/readme.md +++ b/Generische_Typen_009/readme.md @@ -1,6 +1,6 @@ # Generische Typen zusammen mit Wildcards einsetzen ## Lernziel - + [Musterlösung](solution/) Gebundene und ungebundene Wildcards einsetzen. diff --git a/Generische_Typen_009/solution/readme.md b/Generische_Typen_009/solution/readme.md new file mode 100644 index 0000000..3cd4d43 --- /dev/null +++ b/Generische_Typen_009/solution/readme.md @@ -0,0 +1,5 @@ +# Lösung: Generische Typen zusammen mit Wildcards einsetzen + +Musterlösung: + +[pr2.generics.wildcards](../../solutions/src/main/java/pr2/generics/wildcards/). diff --git a/readme.md b/readme.md index 5e6c69a..28470cb 100644 --- a/readme.md +++ b/readme.md @@ -73,15 +73,15 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat | 59. | Input und Output | [Rot13-Verschlüsselung](Input_und_Output_014/readme.md) | [✅](Input_und_Output_014/solution/) | | 60. | Input und Output | [Datei zerhacken](Input_und_Output_015/readme.md) | [✅](Input_und_Output_015/solution/) | | 61. | Input und Output | [Serialisierung](Input_und_Output_016/readme.md) | [✅](Input_und_Output_016/solution/) | -| 62. | Generische Typen | [Einen generischen Typ schreiben](Generische_Typen_001/readme.md) | | -| 63. | Generische Typen | [Generische Klasse Pair schreiben](Generische_Typen_002/readme.md) | | -| 64. | Generische Typen | [Generische Klasse Pair erweitern: NumberPair](Generische_Typen_003/readme.md) | | -| 65. | Generische Typen | [Generische Klasse Pair erweitern: SamePair](Generische_Typen_004/readme.md) | | -| 66. | Generische Typen | [PairList](Generische_Typen_005/readme.md) | | -| 67. | Generische Typen | [Wildcard benutzen](Generische_Typen_006/readme.md) | | -| 68. | Generische Typen | [Generische Queue](Generische_Typen_007/readme.md) | | -| 69. | Generische Typen | [`super` und `extends` einsetzen](Generische_Typen_008/readme.md) | | -| 70. | Generische Typen | [Generische Typen zusammen mit Wildcards einsetzen](Generische_Typen_009/readme.md) | | +| 62. | Generische Typen | [Einen generischen Typ schreiben](Generische_Typen_001/readme.md) | [✅](Generische_Typen_001/solution/) | +| 63. | Generische Typen | [Generische Klasse Pair schreiben](Generische_Typen_002/readme.md) | [✅](Generische_Typen_002/solution/) | +| 64. | Generische Typen | [Generische Klasse Pair erweitern: NumberPair](Generische_Typen_003/readme.md) | [✅](Generische_Typen_003/solution/) | +| 65. | Generische Typen | [Generische Klasse Pair erweitern: SamePair](Generische_Typen_004/readme.md) | [✅](Generische_Typen_004/solution/) | +| 66. | Generische Typen | [PairList](Generische_Typen_005/readme.md) | [✅](Generische_Typen_005/solution/) | +| 67. | Generische Typen | [Wildcard benutzen](Generische_Typen_006/readme.md) | [✅](Generische_Typen_006/solution/) | +| 68. | Generische Typen | [Generische Queue](Generische_Typen_007/readme.md) | [✅](Generische_Typen_007/solution/) | +| 69. | Generische Typen | [`super` und `extends` einsetzen](Generische_Typen_008/readme.md) | [✅](Generische_Typen_008/solution/) | +| 70. | Generische Typen | [Generische Typen zusammen mit Wildcards einsetzen](Generische_Typen_009/readme.md) | [✅](Generische_Typen_009/solution/) | | 71. | Geschachtelte Klassen | [Eigene compare-Methode schreiben](Geschachtelte_Klassen_001/readme.md) | | | 72. | Geschachtelte Klassen | [Innere Klasse Beobachter](Geschachtelte_Klassen_002/readme.md) | | | 73. | Geschachtelte Klassen | [Callback mit anonymer Klasse realisieren](Geschachtelte_Klassen_003/readme.md) | | diff --git a/solutions/src/main/java/pr2/generics/einfach/Liste.java b/solutions/src/main/java/pr2/generics/einfach/Liste.java new file mode 100644 index 0000000..25518e5 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/einfach/Liste.java @@ -0,0 +1,90 @@ +package pr2.generics.einfach; + +/** + * Eine einfache, verkettete Liste. + * + * @param Typ der gespeicherten Objekte + */ + +public class Liste { + + /** + * Referenz auf den ersten Knoten. + */ + private ListeNode first; + + /** + * Referenz auf den aktuellen Knoten. + */ + private ListeNode current; + + /** + * Fügt ein neues Element an das Ende der Liste an. + * + * @param data das Element + */ + public void add(T data) { + + ListeNode nextNode = new ListeNode<>(data); + + if (current == null) { + // Liste komplett leer + first = nextNode; + current = nextNode; + } + else { + current.next = nextNode; + current = nextNode; + } + } + + /** + * Liest das Element an der gegebenen Position. + * + * @param index Index, beginnend bei 0. + * @return Das Element oder {@code null}, wenn es nicht gefunden wurde. + */ + public T get(int index) { + int count = 0; + ListeNode node = first; + + while ((node != null) && (count < index)) { + node = node.next; + count++; + } + + if ((count == index) && (node != null)) { + return node.data; + } + else { + // index does not exist + return null; + } + } + + /** + * Löscht die Liste und entfernt alle Elemente. + */ + public void clear() { + first = null; + current = null; + } + + /** + * Liefert die Anzahl der Elemente der Liste zurück. + * + * @return die Anzahl der Elemente. + */ + public int size() { + int count = 0; + ListeNode node = first; + + while (node != null) { + node = node.next; + count++; + } + + return count; + } +} + diff --git a/solutions/src/main/java/pr2/generics/einfach/ListeNode.java b/solutions/src/main/java/pr2/generics/einfach/ListeNode.java new file mode 100644 index 0000000..b981cd2 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/einfach/ListeNode.java @@ -0,0 +1,30 @@ +package pr2.generics.einfach; + + +/** + * Interne Repräsentation der Knoten in der Liste. + * + * @param Typ der gespeicherten Daten. + */ +class ListeNode { + + /** + * Daten. + */ + T data; + + /** + * Referenz auf den nächsten Knoten. + */ + ListeNode next; + + /** + * Legt einen neuen Knoten an. + * + * @param data daten, die gespeichert werden + */ + ListeNode(T data) { + this.data = data; + } +} + diff --git a/solutions/src/main/java/pr2/generics/einfach/test/ListeTest.java b/solutions/src/main/java/pr2/generics/einfach/test/ListeTest.java new file mode 100644 index 0000000..b9d09bc --- /dev/null +++ b/solutions/src/main/java/pr2/generics/einfach/test/ListeTest.java @@ -0,0 +1,61 @@ +package pr2.generics.einfach.test; + +import org.junit.jupiter.api.Test; +import pr2.generics.einfach.Liste; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +/** + * Test für die Liste. + */ +public class ListeTest { + + /** + * Testet das Hinzufügen und Löschen der Liste. + */ + @Test + void testAddAndClear() { + Liste l = new Liste<>(); + + assertEquals(0, l.size()); + + l.add("Hallo"); + assertEquals(1, l.size()); + l.add("Hugo"); + assertEquals(2, l.size()); + l.add("Peter"); + l.add("Alfons"); + assertEquals(4, l.size()); + + l.clear(); + assertEquals(0, l.size()); + } + + /** + * Testet das Lesen von Elementen. + */ + @Test + void testGet() { + Liste l = new Liste<>(); + l.add("Hallo"); + l.add("Hugo"); + l.add("Peter"); + l.add("Alfons"); + + assertNull(l.get(-1)); + assertNull(l.get(4)); + assertEquals("Hallo", l.get(0)); + assertEquals("Hugo", l.get(1)); + assertEquals("Peter", l.get(2)); + assertEquals("Alfons", l.get(3)); + + assertEquals(4, l.size()); + l.clear(); + assertEquals(0, l.size()); + assertNull(l.get(0)); + assertNull(l.get(1)); + assertNull(l.get(2)); + assertNull(l.get(3)); + } +} diff --git a/solutions/src/main/java/pr2/generics/number_pair/Main.java b/solutions/src/main/java/pr2/generics/number_pair/Main.java new file mode 100644 index 0000000..fcbc53b --- /dev/null +++ b/solutions/src/main/java/pr2/generics/number_pair/Main.java @@ -0,0 +1,15 @@ +package pr2.generics.number_pair; + +public class Main { + public static void main(String[] args) { + var note = new Pair("Peter", 1); + var name = new Pair("Peter", "Meier"); + var tel = new NumberPair(621, 292122); + + System.out.printf("%s:%d\n", note.getFirst(), note.getSecond()); + + System.out.printf("%s %s\n", name.getFirst(), name.getSecond()); + + System.out.printf("%d %d\n", tel.getFirst(), tel.getSecond()); + } +} diff --git a/solutions/src/main/java/pr2/generics/number_pair/NumberPair.java b/solutions/src/main/java/pr2/generics/number_pair/NumberPair.java new file mode 100644 index 0000000..beaa2cf --- /dev/null +++ b/solutions/src/main/java/pr2/generics/number_pair/NumberPair.java @@ -0,0 +1,8 @@ +package pr2.generics.number_pair; + +public class NumberPair extends Pair { + + public NumberPair(T first, T second) { + super(first, second); + } +} diff --git a/solutions/src/main/java/pr2/generics/number_pair/Pair.java b/solutions/src/main/java/pr2/generics/number_pair/Pair.java new file mode 100644 index 0000000..63d841e --- /dev/null +++ b/solutions/src/main/java/pr2/generics/number_pair/Pair.java @@ -0,0 +1,20 @@ +package pr2.generics.number_pair; + +public class Pair { + + private final T first; + private final V second; + + public Pair(T first, V second) { + this.first = first; + this.second = second; + } + + public T getFirst() { + return first; + } + + public V getSecond() { + return second; + } +} diff --git a/solutions/src/main/java/pr2/generics/pair/Main.java b/solutions/src/main/java/pr2/generics/pair/Main.java new file mode 100644 index 0000000..2df11ce --- /dev/null +++ b/solutions/src/main/java/pr2/generics/pair/Main.java @@ -0,0 +1,17 @@ +package pr2.generics.pair; + +public class Main { + public static void main(String[] args) { + var note1 = new Pair("Peter", 1); + var note2 = new Pair("Frank", 3); + var note3 = new Pair("Sabine", 1); + + var name = new Pair("Peter", "Meier"); + + System.out.printf("%s:%d\n", note1.getFirst(), note1.getSecond()); + System.out.printf("%s:%d\n", note2.getFirst(), note1.getSecond()); + System.out.printf("%s:%d\n", note3.getFirst(), note1.getSecond()); + + System.out.printf("%s %s\n", name.getFirst(), name.getSecond()); + } +} diff --git a/solutions/src/main/java/pr2/generics/pair/Pair.java b/solutions/src/main/java/pr2/generics/pair/Pair.java new file mode 100644 index 0000000..8680eb1 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/pair/Pair.java @@ -0,0 +1,20 @@ +package pr2.generics.pair; + +public class Pair { + + private final T first; + private final V second; + + public Pair(T first, V second) { + this.first = first; + this.second = second; + } + + public T getFirst() { + return first; + } + + public V getSecond() { + return second; + } +} diff --git a/solutions/src/main/java/pr2/generics/pairlist/Main.java b/solutions/src/main/java/pr2/generics/pairlist/Main.java new file mode 100644 index 0000000..d414e41 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/pairlist/Main.java @@ -0,0 +1,19 @@ +package pr2.generics.pairlist; + +public class Main { + public static void main(String[] args) { + var note1 = new Pair("Peter", 1); + var note2 = new Pair("Frank", 3); + var note3 = new Pair("Sabine", 1); + + var pl = new PairList(3); + pl.add(note1); + pl.add(note2); + pl.add(note3); + + for (int i = 0; i < 3; i++) { + System.out.printf("%s:%d\n", pl.get(i).getFirst(), + pl.get(i).getSecond()); + } + } +} diff --git a/solutions/src/main/java/pr2/generics/pairlist/Pair.java b/solutions/src/main/java/pr2/generics/pairlist/Pair.java new file mode 100644 index 0000000..3fbbfdf --- /dev/null +++ b/solutions/src/main/java/pr2/generics/pairlist/Pair.java @@ -0,0 +1,20 @@ +package pr2.generics.pairlist; + +public class Pair { + + private final T first; + private final V second; + + public Pair(T first, V second) { + this.first = first; + this.second = second; + } + + public T getFirst() { + return first; + } + + public V getSecond() { + return second; + } +} diff --git a/solutions/src/main/java/pr2/generics/pairlist/PairList.java b/solutions/src/main/java/pr2/generics/pairlist/PairList.java new file mode 100644 index 0000000..0d6a7e1 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/pairlist/PairList.java @@ -0,0 +1,20 @@ +package pr2.generics.pairlist; + +public class PairList { + + protected final Pair[] elements; + protected int pos; + + @SuppressWarnings("unchecked") + public PairList(int size) { + elements = (Pair[]) new Pair[size]; + } + + public void add(Pair element) { + elements[pos++] = element; + } + + public Pair get(int index) { + return elements[index]; + } +} diff --git a/solutions/src/main/java/pr2/generics/printer/CollectionPrinter.java b/solutions/src/main/java/pr2/generics/printer/CollectionPrinter.java new file mode 100644 index 0000000..4c895ab --- /dev/null +++ b/solutions/src/main/java/pr2/generics/printer/CollectionPrinter.java @@ -0,0 +1,11 @@ +package pr2.generics.printer; + +import java.util.Collection; + +public class CollectionPrinter { + public static void print(Collection collection) { + for (Object object : collection) { + System.out.println(object); + } + } +} diff --git a/solutions/src/main/java/pr2/generics/printer/Main.java b/solutions/src/main/java/pr2/generics/printer/Main.java new file mode 100644 index 0000000..4f162d5 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/printer/Main.java @@ -0,0 +1,23 @@ +package pr2.generics.printer; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class Main { + public static void main(String[] args) { + List ls = new ArrayList<>(); + List li = new ArrayList<>(); + ls.add("PR2"); + ls.add("ist"); + ls.add("cool"); + Set s = new HashSet<>(ls); + li.add(23); + li.add(42); + + CollectionPrinter.print(ls); + CollectionPrinter.print(li); + CollectionPrinter.print(s); + } +} diff --git a/solutions/src/main/java/pr2/generics/queue/Queue.java b/solutions/src/main/java/pr2/generics/queue/Queue.java new file mode 100644 index 0000000..258604a --- /dev/null +++ b/solutions/src/main/java/pr2/generics/queue/Queue.java @@ -0,0 +1,39 @@ +package pr2.generics.queue; + +public class Queue { + + private final T[] elements; + private int pos = 0; + private int pos2 = 0; + + @SuppressWarnings("unchecked") + public Queue(int size) { + elements = (T[]) new Object[size]; + } + + public void offer(T element) { + elements[pos] = element; + pos++; + pos = pos % elements.length; + } + + public T poll() { + T element = elements[pos2]; + elements[pos2] = null; + pos2++; + pos2 = pos2 % elements.length; + return element; + } + + public void addAll(Queue other) { + for (T t : other.elements) { + offer(t); + } + } + + public void copyInto(Queue other) { + for (T t : elements) { + other.offer(t); + } + } +} diff --git a/solutions/src/main/java/pr2/generics/same_pair/Main.java b/solutions/src/main/java/pr2/generics/same_pair/Main.java new file mode 100644 index 0000000..0b85368 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/same_pair/Main.java @@ -0,0 +1,15 @@ +package pr2.generics.same_pair; + +public class Main { + public static void main(String[] args) { + var note = new Pair("Peter", 1); + var name = new SamePair("Peter", "Meier"); + var tel = new SamePair(621, 2009992); + + System.out.printf("%s:%d\n", note.getFirst(), note.getSecond()); + + System.out.printf("%s %s\n", name.getFirst(), name.getSecond()); + + System.out.printf("%d %d\n", tel.getFirst(), tel.getSecond()); + } +} diff --git a/solutions/src/main/java/pr2/generics/same_pair/Pair.java b/solutions/src/main/java/pr2/generics/same_pair/Pair.java new file mode 100644 index 0000000..587225a --- /dev/null +++ b/solutions/src/main/java/pr2/generics/same_pair/Pair.java @@ -0,0 +1,20 @@ +package pr2.generics.same_pair; + +public class Pair { + + private final T first; + private final V second; + + public Pair(T first, V second) { + this.first = first; + this.second = second; + } + + public T getFirst() { + return first; + } + + public V getSecond() { + return second; + } +} diff --git a/solutions/src/main/java/pr2/generics/same_pair/SamePair.java b/solutions/src/main/java/pr2/generics/same_pair/SamePair.java new file mode 100644 index 0000000..32323a8 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/same_pair/SamePair.java @@ -0,0 +1,8 @@ +package pr2.generics.same_pair; + +public class SamePair extends Pair { + + public SamePair(T first, T second) { + super(first, second); + } +} diff --git a/solutions/src/main/java/pr2/generics/super_extends/Liste.java b/solutions/src/main/java/pr2/generics/super_extends/Liste.java new file mode 100644 index 0000000..26cce2b --- /dev/null +++ b/solutions/src/main/java/pr2/generics/super_extends/Liste.java @@ -0,0 +1,108 @@ +package pr2.generics.super_extends; + +/** + * Eine einfache, verkettete Liste. + * + * @param Typ der gespeicherten Objekte + */ +public class Liste { + + /** + * Referenz auf den ersten Knoten. + */ + private ListeNode first; + + /** + * Referenz auf den aktuellen Knoten. + */ + private ListeNode current; + + /** + * Fügt ein neues Element an das Ende der Liste an. + * + * @param data das Element + */ + public void add(T data) { + + ListeNode nextNode = new ListeNode<>(data); + + if (current == null) { + // Liste komplett leer + first = nextNode; + current = nextNode; + } + else { + current.next = nextNode; + current = nextNode; + } + } + + /** + * Liest das Element an der gegebenen Position. + * + * @param index Index, beginnend bei 0. + * @return Das Element oder {@code null}, wenn es nicht gefunden wurde. + */ + public T get(int index) { + int count = 0; + ListeNode node = first; + + while ((node != null) && (count < index)) { + node = node.next; + count++; + } + + if ((count == index) && (node != null)) { + return node.data; + } + else { + // index does not exist + return null; + } + } + + /** + * Löscht die Liste und entfernt alle Elemente. + */ + public void clear() { + first = null; + current = null; + } + + /** + * Liefert die Anzahl der Elemente der Liste zurück. + * + * @return die Anzahl der Elemente. + */ + public int size() { + int count = 0; + ListeNode node = first; + + while (node != null) { + node = node.next; + count++; + } + + return count; + } + + /** + * Kopiert alle Elemente dieser Liste in die andere Liste. + * + * @param other die andere Liste. + */ + public void copyInto(Liste other) { + for (int i = 0; i < size(); i++) { + other.add(get(i)); + } + } + + /** + * Füllt diese Liste mit dem Inhalt der übergebenen Liste. + * + * @param other die andere Liste. + */ + public void fillFrom(Liste other) { + other.copyInto(this); + } +} diff --git a/solutions/src/main/java/pr2/generics/super_extends/ListeNode.java b/solutions/src/main/java/pr2/generics/super_extends/ListeNode.java new file mode 100644 index 0000000..487f1b1 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/super_extends/ListeNode.java @@ -0,0 +1,28 @@ +package pr2.generics.super_extends; + +/** + * Interne Repräsentation der Knoten in der Liste. + * + * @param Typ der gespeicherten Daten. + */ +class ListeNode { + + /** + * Daten. + */ + T data; + + /** + * Referenz auf den nächsten Knoten. + */ + ListeNode next; + + /** + * Legt einen neuen Knoten an. + * + * @param data daten, die gespeichert werden + */ + ListeNode(T data) { + this.data = data; + } +} \ No newline at end of file diff --git a/solutions/src/main/java/pr2/generics/super_extends/test/ListeTest.java b/solutions/src/main/java/pr2/generics/super_extends/test/ListeTest.java new file mode 100644 index 0000000..84997ad --- /dev/null +++ b/solutions/src/main/java/pr2/generics/super_extends/test/ListeTest.java @@ -0,0 +1,42 @@ +package pr2.generics.super_extends.test; + +import org.junit.jupiter.api.Test; +import pr2.generics.super_extends.Liste; + +import static org.junit.jupiter.api.Assertions.assertEquals; + + +/** + * Test für die Liste. + */ +public class ListeTest { + + /** + * Testet das Umkopieren. + */ + @Test + void testAddAndClear() { + Liste ls = new Liste<>(); + Liste lo = new Liste<>(); + + ls.add("Hallo"); + ls.add("Hugo"); + ls.add("Peter"); + ls.add("Alfons"); + + ls.copyInto(lo); + + assertEquals("Hallo", lo.get(0)); + assertEquals("Hugo", lo.get(1)); + assertEquals("Peter", lo.get(2)); + assertEquals("Alfons", lo.get(3)); + + lo = new Liste<>(); + lo.fillFrom(ls); + + assertEquals("Hallo", lo.get(0)); + assertEquals("Hugo", lo.get(1)); + assertEquals("Peter", lo.get(2)); + assertEquals("Alfons", lo.get(3)); + } +} diff --git a/solutions/src/main/java/pr2/generics/wildcards/ListHelper.java b/solutions/src/main/java/pr2/generics/wildcards/ListHelper.java new file mode 100644 index 0000000..a6aba36 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/wildcards/ListHelper.java @@ -0,0 +1,35 @@ +package pr2.generics.wildcards; + +/** + * Klasse zum Ausdrucken von Listen. + */ +public class ListHelper { + + /** + * Druckt alle Elemente der Liste auf der Konsole aus. + * + * @param liste Die zu druckende Liste. + */ + public static void printList(SimpleList liste) { + for (Object o : liste) { + System.out.println(o); + } + } + + /** + * Summiert die Elemente der Liste. Deswegen können nur Listen übergeben + * werden, deren Elemente mindestens vom Typ {@code Number} sind. + * + * @param liste Die Liste, deren Elemente summiert werden sollen. + * @return das Ergebnis + */ + public static double sumList(SimpleList liste) { + double sum = 0; + + for (Number number : liste) { + sum += number.doubleValue(); + } + + return sum; + } +} diff --git a/solutions/src/main/java/pr2/generics/wildcards/Main.java b/solutions/src/main/java/pr2/generics/wildcards/Main.java new file mode 100644 index 0000000..6401bdc --- /dev/null +++ b/solutions/src/main/java/pr2/generics/wildcards/Main.java @@ -0,0 +1,39 @@ +package pr2.generics.wildcards; + +/** + * Ausgabe der Liste. + */ +public final class Main { + + /** + * Constructor. + */ + private Main() { + // keine Instanzen + } + + /** + * Haupt-Methode. + * + * @param args Kommandozeilenargumente. + */ + public static void main(String[] args) { + SimpleList l1 = new SimpleList<>(); + l1.add("Dies"); + l1.add("ist"); + l1.add("ein"); + l1.add("Test"); + l1.add("."); + + SimpleList l2 = new SimpleList<>(); + l2.add(1); + l2.add(2); + l2.add(3); + l2.add(4); + l2.add(5); + + ListHelper.printList(l1); + ListHelper.printList(l2); + System.out.println(ListHelper.sumList(l2)); + } +} diff --git a/solutions/src/main/java/pr2/generics/wildcards/SimpleList.java b/solutions/src/main/java/pr2/generics/wildcards/SimpleList.java new file mode 100644 index 0000000..b4241c1 --- /dev/null +++ b/solutions/src/main/java/pr2/generics/wildcards/SimpleList.java @@ -0,0 +1,12 @@ +package pr2.generics.wildcards; + +import java.util.ArrayList; + +/** + * Listenklasse. + * + * @param Typ, der in der Liste gespeichert wird. + */ +public class SimpleList extends ArrayList { + // nothing here +}