master #12
|
|
@ -0,0 +1,25 @@
|
|||
# Deep-Copy mit `clone()`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Im Paket [pr2.object.clone_alien](../sources/src/main/java/pr2/object/clone_alien/) fügen Sie der Klasse `Alien` eine `clone()`-Methode hinzu, die eine _tiefe Kopie_ der Objekte anlegt. Hierzu müssen Sie auch Raumanzug mit einer `clone()`-Methode ausstatten.
|
||||
|
||||
Testen Sie, ob Ihre Implementierung korrekt funktioniert, indem Sie die vorhandenen Testfälle ausführen. Damit die Tests laufen können, müssen Sie die Kommentarzeichen entfernen.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Clone
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Den Nutzen der `clone()`-Methode verstehen und diese richtig einsetzen. Eine eigene `clone()`-Methode schreiben und eine tiefe Kopie durchführen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Im Paket [pr2.object.clone_person](../sources/src/main/java/pr2/object/clone_person) finden Sie die Klasse `Person`.
|
||||
|
||||
Erweitern Sie die Klasse bitte um eine `clone()`-Methode, die eine tiefe Kopie (**deep copy**) durchführt.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# `equals()` und `hashCode()` implementieren und nutzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Im Projekt finden Sie ein Paket [pr2.object.equals_hashcode](../sources/src/main/java/pr2/object/equals_hashcode/) mit zwei Klassen `Wesen` und `Ork` und einen Testfall `WesenTest`.
|
||||
|
||||
Wenn Sie den Test ausführen wird er nicht erfolgreich sein, da die Methoden `equals` und `hashCode` in der Klasse Ork fehlen.
|
||||
|
||||
Schauen Sie sich die `equals`- und `hashCode`-Methoden in `Wesen` an und versuchen Sie die Methoden zu verstehen.
|
||||
|
||||
Schreiben Sie im nächsten Schritt korrekte `equals`- und `hashCode`-Methoden für `Ork`. __Achtung:__ Sie sollten für Ihre Lösung die Klasse `Wesen` nicht verändern.
|
||||
|
||||
Führen Sie den Test erneut aus, um sicherzustellen, dass die Methoden richtig funktionieren.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# equals und hashCode
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Die Methoden `equals()` und `hashCode()` der Klasse `Object` korrekt überschreiben und nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Im Paket [pr2.object.equals_person](../sources/src/main/java/pr2/object/equals_person) finden Sie die Klasse `Person`.
|
||||
|
||||
Geben Sie bitte den Java-Quelltext einer `equals`- und `hashCode`-Methode für diese Klasse an, die die in der Klasse `java.lang.Object` zugesicherte Äquivalenzbeziehung einhalten.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# `toString()`-Methode implementieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Klassen mit einer `toString()`-Methode versehen und diese gegenseitig nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.object.tostring](../sources/src/main/java/pr2/object/tostring/).
|
||||
|
||||
Lassen Sie die Klasse `Ausgabe` laufen und sehen Sie sich die Ausgabe an. Versuchen Sie zu verstehen, wie es zu dieser Ausgabe kommt und was sie bedeutet.
|
||||
|
||||
Schreiben Sie im nächsten Schritt für die Klassen `Alien` und `Raumanzug` passende `toString()`-Methoden, sodass beim Aufruf der Klasse `Ausgabe` eine sinnvolle Ausgabe entsteht. Geben Sie
|
||||
|
||||
* den Namen des Aliens,
|
||||
* die Marke des Raumanzuges und
|
||||
* den vorhandenen Sauerstoffvorrat
|
||||
|
||||
aus.
|
||||
|
||||
Eine beispielhafte Ausgabe könnte wie folgt aussehen:
|
||||
|
||||
`Ich bin ein Alien und heiße 'E.T.'. Ich trage einen Raumanzug von Spaceman 2000 (Füllstand 19%).`
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Optimierung bei Integer
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Wrapper-Klassen und deren Optimierungen verstehen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.object.wrapper_boxsearch](../sources/src/main/java/pr2/object/wrapper_boxsearch/).
|
||||
|
||||
Bei den Wrapper-Typen (z.B. `Integer`) wird eine interne Optimierung durchgeführt, die dazu führt, dass bei Werten unterhalb einer bestimmten Schranke, beim Autoboxing immer wieder dasselbe Objekt verwendet wird, anstatt ein neues Wrapper-Objekt zu erzeugten.
|
||||
|
||||
Schreiben Sie bitte ein Programm in der Klasse `BoxSearcher`, das für `Integer` diese Schranke sucht, indem es die Werte von `0` bis `200` auf diese Eigenschaft hin untersucht und für jeden Integer-Wert ausgibt, ob der Mechanismus bei ihm greift oder nicht.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
# Methoden der Wrapper-Klassen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Wrapper-Klassen nutzen, um Zahlen umzuwandeln.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.object.wrapper_umwandler](../sources/src/main/java/pr2/object/wrapper_umwandler/).
|
||||
|
||||
Vervollständigen Sie die Klasse `Umwandler` so, dass die Methode `toString` eine Zahl nimmt und in vier verschiedenen Formaten ausgibt. Schauen Sie sich die Klasse `Integer` an und überlegen Sie, welche der vorhandenen statischen Methoden für das Problem passend sein könnten.
|
||||
|
||||
Eine beispielhafte könnte wie folgt aussehen:
|
||||
|
||||
```console
|
||||
Dezimal: 17871
|
||||
Hex : 45cf
|
||||
Oktal : 42717
|
||||
Binär : 100010111001111
|
||||
```
|
||||
|
||||
Im nächsten Schritt stellen Sie bitte die Methode `fromString` fertig. Auch hierzu sollten Sie sich die Klasse `Integer` genauer anschauen.
|
||||
|
||||
Führen Sie das Programm aus und schauen Sie, ob das Ergebnis sinnvoll ist.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Eigene Enumeration schreiben und verwenden
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine einfache Enumeration (ohne abstrakte Methoden) erstellen und in einem kleinen Programm einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.enums.eigene](../sources/src/main/java/pr2/enums/eigene_enumeration/).
|
||||
|
||||
In Rollenspielen verwendet man oft Würfel mit einer unterschiedlichen Anzahl von Seiten. Üblich sind 4-, 6-, 8-, 10-, und 12-seitige Würfel. Das vorliegende Programm erlaubt es unterschiedliche Würfel zu simulieren.
|
||||
|
||||
Betrachten Sie das vorliegende Projekt. Darin gibt es eine Klasse `Wuerfel`, die einen Würfel in einem Rollenspiel simulieren kann und einen dazugehörigen Test in `WuerfelTest`. Welche Art von Würfel man haben möchte, setzt man über den Konstruktorparameter von `Wuerfel` und die entsprechenden Konstanten (z.B. `D6`). Lassen Sie die Unit-Test laufen. Wahrscheinlich wird einer fehlschlagen. Korrigieren Sie den Fehler, damit alle Tests grün sind.
|
||||
|
||||
Das Problem mit der vorliegenden Klasse ist, dass man auch Würfel mit einer anderen Augenzahl (insbesondere ungerade) erzeugen kann. Um dies zu verhindern, sollen Sie das Programm auf die Verwendung von Enumerationen umstellen.
|
||||
|
||||
Schreiben Sie eine Enumeration `WuerfelTyp`, die über die Konstanten `D4`, `D6`,`D8`, `D10` und `D12` die möglichen Würfelarten vorgibt. Ändern Sie den Konstruktorparameter von `Wuerfel` so, dass er anstatt eines `int` einen `WuerfelTyp` nimmt. Damit das Programm erweiterbar bleibt, speichern Sie die Anzahl der Seiten, die zu den jeweiligen Typen gehören in der Enumeration und nicht in der Klasse `Wuerfel`. Geben Sie der Enumeration außerdem eine Methode mit, welche den erwarteten Durchschnittswert für eine große Anzahl von Würfen zurückgibt (Methodenname `average`).
|
||||
|
||||
Ändern Sie die Tests so, dass sie mit der Enumeration arbeiten. Codieren Sie die Enum-Werte (`D4`...`D12`) nicht hart im Test, sondern verwenden Sie die Methode `values()`, um die Tests möglichst generisch zu gestalten.
|
||||
|
||||
Fügen Sie nun einen weiteren Würfeltyp `D20` ein und testen Sie diesen. Wenn Sie alles richtig gemacht haben, müssen Sie hierfür nur die Enumeration `WuerfelTyp` ändern, alle anderen Klassen bleiben unverändert.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# Enumeration schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine einfache Enumeration (ohne abstrakte Methoden) erstellen und in einem kleinen Programm einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.enums.filme](../sources/src/main/java/pr2/enums/filme/).
|
||||
|
||||
Schreiben Sie eine Enumeration `LieblingsFilme`, die Ihre Lieblingsfilme enthalten soll. Speichern Sie zu jedem Film bitte den Titel, den Regisseur und eine Bewertung auf einer Skala von 0 bis 10. Bieten Sie weiterhin eine `toString`-Methode an, die diese Informationen wieder ausgibt und denken Sie an Methoden, um später wieder auf die Daten zu den Filmen zugreifen zu können.
|
||||
|
||||
Schreiben Sie eine Klasse `Main`, welche alle Lieblingsfilme auf der Konsole ausgibt.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# Singleton-Eigenschaft von Enumerationen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Die Singleton-Eigenschaft von Enumerationen verstehen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.enums.singleton](../sources/src/main/java/pr2/enums/singleton/).
|
||||
|
||||
Enumerationen werden in Java durch echte Klassen und Objekte dargestellt. Eine Besonderheit ist allerdings, dass von jeder Enumerationskonstante immer genau ein Objekt existiert, es sich also um Singletons handelt. Daher darf man Java-Enumerationen sicher mit `==` vergleichen.
|
||||
|
||||
Schreiben Sie bitte ein kleines Java-Programm `SingletonBeweis`, das nachweist, dass es sich bei Enumerationen wirklich um Singletons handelt. Verwenden Sie dazu die bereits vorgegebene Enumeration `MyEnum`.
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
# Eine vorhandene Enumeration nutzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Syntax von Enumerationen verstehen und einfache Einsatzzwecke kennenlernen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.enums.verwenden](../sources/src/main/java/pr2/enums/verwenden/).
|
||||
|
||||
In dieser Aufgabe sollen Sie mit einer vorhandenen Enumeration experimentieren. Sehen Sie sich hierzu die vorhandenen Klassen an. Insbesondere das Sprite `Professor`.
|
||||
|
||||
Im Konstruktor von `Professor` wird eine Enumeration namens `BoundaryPolicy` genutzt. Schauen Sie sich die JavaDoc der Enumeration an und versuchen Sie zu verstehen, was gemeint ist.
|
||||
|
||||
Testen Sie nun die verschiedenen Werte der Enumeration durch und betrachten Sie, wie sich das Sprite anders verhält.
|
||||
|
||||
Überlegen Sie, warum hier eine Enumeration verwendet wurde und nicht etwas Vererbung mit dem Überschreiben von Methoden.
|
||||
|
||||
## Abgabe
|
||||
|
||||
Für diese Aufgabe ist keine Abgabe vorgesehen.
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
|
|
@ -0,0 +1,51 @@
|
|||
# Assignment: Stein, Papier, Schere, Echse, Spock
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Mit Enumerationen arbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.enums.schnick](../sources/src/main/java/pr2/enums/schnick).
|
||||
|
||||
|
||||
|
||||
Schreiben Sie ein einfaches Spiel (Klasse `SchnickSchnackSchnuck`), bei dem Sie gegen den Computer Schnick-Schnack-Schnuck spielen (auch Rock, Paper, Scissors genannt) mit folgenden Eigenschaften:
|
||||
|
||||
* Das Spiel geht über drei Runden.
|
||||
* Es fragt den Spieler nach seiner Auswahl (r, p, s).
|
||||
* Der Computer zieht zufällig eine der drei Möglichkeiten.
|
||||
* Nach jeder Runde sagt das Spiel, wer welche Möglichkeit gewählt hat und wer die Runde gewonnen hat.
|
||||
* Ein Sieg bringt einen Punkt, ein Unentschieden 0 Punkte.
|
||||
* Die Punkte jeder Runde werden addiert.
|
||||
* Am Ende wird der Gesamtpunktestand ausgegeben.
|
||||
|
||||
Eine beispielhafte Session mit dem Programm sieht dann wie folgt aus:
|
||||
|
||||
```console
|
||||
Runde 1: Dein Zug ([r]rock, [p]aper, [s]cissors)? r
|
||||
Der Computer hat gewonnen - Du: ROCK, Computer: PAPER - [0:1]
|
||||
|
||||
Runde 2: Dein Zug ([r]rock, [p]aper, [s]cissors)? p
|
||||
Unentschieden - Du: PAPER, Computer: PAPER - [0:1]
|
||||
|
||||
Runde 3: Dein Zug ([r]rock, [p]aper, [s]cissors)? s
|
||||
Du hast gewonnen: Du: SCISSORS, Computer: PAPER - [1:1]### Abgabe
|
||||
Ergebnis - Du 1 Punkt(e), Computer 1 Punkt(e)
|
||||
```
|
||||
|
||||
Repräsentieren Sie die Züge mithilfe einer Enumeration `Move`. Diese soll auch die Tasten beinhalten, welche man für die einzelnen Züge (`r`, `p`, `s`) drücken muss.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -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`.
|
||||
|
|
@ -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`.
|
||||
|
|
@ -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`.
|
||||
|
|
@ -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`.
|
||||
|
|
@ -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`.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
# `BufferedReader` zum zeilenweisen Lesen einsetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten Zeilenweise mit einem `BufferedReader` verwenden und dabei das Decorator Pattern einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.buffered_reader](../sources/src/main/java/pr2/io/buffered_reader/).
|
||||
|
||||
Lesen Sie die Datei [kafka.txt](assets/kafka.txt) zeilenweise ein und geben Sie die Zeilen mit einer fortlaufenden Zeilennummer wieder aus. Verwenden Sie hierzu einen `BufferedReader`.
|
||||
|
||||
Eine beispielhaft Ausgabe sieht wie folgt aus:
|
||||
|
||||
```console
|
||||
1: Verhaftung - Gespräch mit Frau Grubach - Dann Fräulein Bürstner
|
||||
2:
|
||||
3: Jemand mußte Josef K. verleumdet haben, denn ohne daß er etwas Böses
|
||||
4: getan hätte, wurde er eines Morgens verhaftet. Die Köchin der Frau
|
||||
5: Grubach, seiner Zimmervermieterin, die ihm jeden Tag gegen acht Uhr früh
|
||||
6: das Frühstück brachte, kam diesmal nicht. Das war noch niemals
|
||||
```
|
||||
|
||||
Lassen Sie das Programm laufen und überprüfen Sie, ob die Ausgabe korrekt ist. Die Beispieldatei hat 232 Zeilen.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# DataOutputStream
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten mit einem `DataOutputStreams` manuell serialisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datainputoutput_1](../sources/src/main/java/pr2/io/datainputoutput_1/).
|
||||
|
||||
Schreiben Sie eine Klasse `DateWriter`, die ein Datum in der Form yyyy-MM-dd (z.B. 1997-08-29) von der Konsole annimmt und als `long`-Wert mithilfe eines `DataOutputStreams` in eine Datei schreibt.
|
||||
|
||||
Schreiben Sie eine Klasse `DateReader`, die den `long`-Wert aus der Datei ausliest und wieder in das ursprüngliche Format bringt und auf der Konsole ausgibt.
|
||||
|
||||
**Hinweis:** Zur Konvertierung eines Strings in ein Datum und umgekehrt, können Sie die Klasse `SimpleDateFormat` verwenden. Ein `Date`-Objekt lässt sich leicht über die Methode `getTime` in einen `long`-Wert umwandeln. Denken Sie an eine korrekte Behandlung von möglichen Fehlern.
|
||||
|
||||
```console
|
||||
> java DateWriter 1997-08-29
|
||||
> java DateReader
|
||||
Das Datum war: 1997-08-29
|
||||
```
|
||||
|
||||
**Zusatzfrage:** Welche besondere Bedeutung hat das hier als Beispiel verwendete Datum?
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# DataOutputStream durch Serialisierung ersetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten mit einem `ObjectOutputStreams` serialisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datainputoutput_2](../sources/src/main/java/pr2/io/datainputoutput_2/).
|
||||
|
||||
Verändern Sie die beiden Klassen aus der vorhergehenden Aufgabe so, dass sie jetzt anstatt eines `DataOutputStreams` bzw. eines `DataInputStreams` Serialisierung verwenden.
|
||||
|
||||
Vergleichen Sie bitte die Dateien, die bei diesem und der anderen Lösung entstanden sind. Was fällt ihnen auf?
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
# Daten mit `DataOutputStream` und `DataInputStream` verarbeiten
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Ein eigenes Format für die Daten einer Klasse definieren und diese Dann in einer Datei speichern und aus dieser wieder laden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.data_output](../sources/src/main/java/pr2/io/data_output/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
|
||||
|
||||
Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
|
||||
|
||||
Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
|
||||
|
||||
Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von `DateOutputStream` und `DataInputStream`. Hierzu müssen Sie noch das Datenformat für die Speicherung festlegen. Dieses ist wie folgt definiert:
|
||||
|
||||
1. Als erstes der String "Schachbrett" im UTF8-Format, um das Datenformat zu kennzeichnen.
|
||||
2. Die Koordinaten der ersten Figur im Format x-Pos, y-Pos (beide als `byte`) und Farbe entsprechend `Color.ordinal()` (als `int`)
|
||||
3. Wiederholung von Schritt 2. bis alle Figuren gespeichert sind.
|
||||
4. Werte `0xff`, `0xff`, `-1`, um das Dateiende zu kennzeichnen
|
||||
|
||||
Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet 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`.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Daten mit einem `InputStream` lesen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen `InputStream` benutzen, um Daten aus einer Datei zu lesen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datei_lesen](../sources/src/main/java/pr2/io/datei_lesen/).
|
||||
|
||||
Lesen Sie die Daten aus der Datei `daten.dat` byteweise und geben Sie den Inhalt auf der Konsole aus. Für die Ausgabe verwenden Sie bitte die Hexadezimale Darstellung, also z.B. `0x0a` für den Wert 11.
|
||||
|
||||
Lassen Sie das Programm laufen und betrachten Sie die Ausgabe. Wenn Sie alles korrekt implementiert haben, sollten Sie den Text
|
||||
|
||||
0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
|
||||
|
||||
sehen.
|
||||
|
||||
Denken Sie auch an eine Fehlerbehandlung für eventuelle Ausnahmen im Zusammenhang mit der Datei.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Daten mit einem `OutputStream` schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen `OutputStream` verwenden, um Daten zu schreiben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.datei_schreiben](../sources/src/main/java/pr2/io/datei_schreiben/).
|
||||
|
||||
In dieser Aufgabe sollen Sie eine Reihe von Bytes in eine Datei schreiben. Ein JUnit-Test wird überprüfen, ob Sie dies richtig getan haben.
|
||||
|
||||
Öffnen Sie einen passenden `OutputStream`, um in die Datei `output/daten.dat` zu schreiben (verwenden Sie die Konstante `FILE` für den Dateinamen). Schreiben Sie nun die Byte-Folge
|
||||
|
||||
```console
|
||||
0xca 0xff 0xfe 0xba 0xbe 0x0 0xde 0xad 0xbe 0xef
|
||||
```
|
||||
|
||||
hinein und schließen Sie die Datei wieder.
|
||||
|
||||
Führen Sie den JUnit-Test aus, der überprüft, ob alle Daten korrekt in die Datei geschrieben wurden.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
# Filesystem-Abstraktion mit `File`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Die Klasse `Path` einsetzen, um plattformunabhängig Operationen auf dem Dateisystem durchzuführen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.file](../sources/src/main/java/pr2/io/file/).
|
||||
|
||||
Benutzen Sie die Klasse `Path`, um die Festplatte Ihres Computers, ausgehend von dem als `root` bezeichneten Verzeichnis `../..` zu durchsuchen und die Größe der Verzeichnisse zu berechnen.
|
||||
|
||||
Sie können die Größe eines Verzeichnisses nur indirekt bestimme, indem Sie die Größe aller Dateien in dem Verzeichnis addieren. Das Verzeichnis direkt kann man _nicht_ mit `size()` nach seiner Größe fragen, wohl aber normale Dateien. Deswegen müssen Sie in Ihrem Programm immer sauber unterscheiden, ob ein Verzeichnis vorliegt (das sie rekursiv durchlaufen müssen) oder eine normale Datei (deren Größe Sie abfragen).
|
||||
|
||||
Geben Sie die Verzeichnisse mit Ihrer Größe aus. Am Ende des Programms geben Sie noch die Gesamtgröße aller Unterverzeichnisse aus. Eine beispielhafte sähe wie folgt aus:
|
||||
|
||||
```console
|
||||
Untersuche: /home/thomas/eclipse-workspace
|
||||
|
||||
465 Byte - /home/thomas/eclipse-workspace/.recommenders/snipmatch/repositories
|
||||
1,4 kByte - /home/thomas/eclipse-workspace/.recommenders/snipmatch
|
||||
4,6 MByte - /home/thomas/eclipse-workspace/.recommenders
|
||||
57,5 MByte - /home/thomas/eclipse-workspace
|
||||
103 Byte - /home/thomas/lib/.settings
|
||||
5,8 MByte - /home/thomas/lib
|
||||
|
||||
Gesamtgröße: 80,4 MByte
|
||||
```
|
||||
|
||||
Lassen Sie Ihr Programm laufen und überprüfen Sie, ob die Ausgaben plausibel sind. Vergleichen Sie das Ergebnis mit den Angaben des Windows-Explorers, Mac-Finders oder Linux-Dateimanagers.
|
||||
|
||||
Unter Linux und MacOS müssen Sie darauf achten, dass Sie symbolischen Links in Ihrem Programm nicht folgen, sonst zählen Sie möglicherweise zu viel.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# Fileattribute lesen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Methoden der Klassen `Path` und `Files` nutzen und verstehen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.filetest](../sources/src/main/java/pr2/io/filetest/).
|
||||
|
||||
Schreiben Sie eine Klasse `FileInfo`, der man auf der Konsole einen Datei- oder Verzeichnisnamen übergeben kann. Sie soll dann einige grundlegende Informationen über die Datei ausgeben (siehe Beispiel).
|
||||
|
||||
```console
|
||||
> java FileTest /Users/thomas/Documents/../Documents/
|
||||
/Users/thomas/Documents existiert
|
||||
/Users/thomas/Documents ist 408 Bytes groß
|
||||
/Users/thomas/Documents ist ein Verzeichnis
|
||||
/Users/thomas/Documents darf gelesen werden
|
||||
/Users/thomas/Documents darf geschrieben werden
|
||||
|
||||
> java FileTest /Users/thomas/Documents/../Documents/Uebungsklausur.pages
|
||||
/Users/thomas/Documents/Uebungsklausur.pages existiert
|
||||
/Users/thomas/Documents/Uebungsklausur.pages ist 258920 Bytes groß
|
||||
/Users/thomas/Documents/Uebungsklausur.pages ist ein normale Datei
|
||||
/Users/thomas/Documents/Uebungsklausur.pages darf gelesen werden
|
||||
/Users/thomas/Documents/Uebungsklausur.pages darf geschrieben 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# `FilterReader`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen eigenen Filter in Form eines `FilterReaders` programmieren und hiermit in den Datenstrom eingreifen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.filter](../sources/src/main/java/pr2/io/filter/).
|
||||
|
||||
Vervollständigen Sie die Klasse `UCaseReader` so, dass Sie als Filter (`FilterReader`) verwendet werden kann. Die Aufgabe dieses Filters besteht darin, alle gelesenen Zeichen in Großbuchstaben umzuwandeln.
|
||||
|
||||
Testen Sie, ob Ihre Implementierung korrekt ist, indem Sie die JUnit-Tests ausführen.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Konsolen Input/Output
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten von der Konsole lesen und über eine Ausgabeumlenkung in eine Datei umlenken. `PrintStream` und `InputStreamReader` einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.konsole](../sources/src/main/java/pr2/io/konsole/).
|
||||
|
||||
Lesen Sie zeilenweise mithilfe eines `BufferedReaders` von der Konsole Zeichen ein. Geben Sie diese wieder auf `System.out` aus und zeigen Sie die aktuelle Zeilennummer auf `System.err` an.
|
||||
|
||||
Testen Sie das Programm.
|
||||
|
||||
Lenken Sie nun die Ausgabe von `System.out` in die Datei `output/console.log` um (siehe Konstante `LOGFILE`). Lassen Sie das Programm erneut laufen und betrachten Sie danach die Datei mit den umgeleiteten Daten.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
# Zeilen einer Textdatei zählen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Dateien zeilenweise lesen und verarbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.linecounter](../sources/src/main/java/pr2/io/linecounter/).
|
||||
|
||||
Schreiben Sie eine Klasse `LineCounter`, die den Namen einer Textdatei von der Kommandozeile entgegennimmt und dann die Anzahl der Zeilen in der Datei ausgibt.
|
||||
|
||||
```console
|
||||
> java LineCounter ../src/LineCounter.java
|
||||
Datei: ../src/LineCounter.java hat 30 Zeilen
|
||||
```
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# `RandomAccessFile`
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
`RandomAccessFile` sowohl zum Lesen, als auch zum Schreiben von Daten einsetzen. Verstehen, dass man sich wahlfrei durch die Datei bewegen kann.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.random_access](../sources/src/main/java/pr2/io/random_access/).
|
||||
|
||||
Bei dieser Aufgabe werden Sie ein Verfahren anwenden, das bei sehr großen Datenmengen zum Einsatz kommt: das Sortieren der Daten direkt auf der Festplatte, ohne sie vollständig in den Hauptspeicher zu laden.
|
||||
|
||||
Implementieren Sie einen [Bubblesort](https://de.wikipedia.org/wiki/Bubblesort) mithilfe von `RandomAccessFile` direkt auf einer Datei. Bubblesort ist ein ausgesprochen ineffizienter Algorithmus (O(n*n)), er ist aber sehr einfach zu implementieren. Da die zu sortierende Datei klein ist, können wir hier mit den Nachteilen von Bubblesort leben.
|
||||
|
||||
Implementieren Sie die bereits vorhandene Methode `sortFile` der Klasse `FileSort`. Öffnen Sie zuerst die Datei mithilfe von `RandomAccessFile` im Modus `"rw"`. Wandern Sie nun - entsprechend dem Bubblesort-Algorithmus - über die Daten und sortieren Sie die Bytes der Datei. Halten Sie nie mehr als zwei `byte` und die Position als `long` im Speicher. Weitere Variablen können auch noch nötig sein, um den Algorithmus zu implementieren.
|
||||
|
||||
Testen Sie Ihre Implementierung mit den JUnit-Tests.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# `Reader` verwenden
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Textdaten mithilfe von `Reader` verarbeiten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.reader_writer](../sources/src/main/java/pr2/io/reader_writer/).
|
||||
|
||||
Lesen Sie die Datei [kafka.txt](assets/kafka.txt) mit einem passenden `Reader` ein und geben Sie sie auf der Konsole aus. Verwenden Sie nicht die `read()`-Methode, die einzelne Zeichen verarbeitet, sondern arbeiten Sie mit einem `char[]`-Buffer.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# Rot13-Verschlüsselung
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Funktionsweise und Einsatz von Filtern.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.rot13](../sources/src/main/java/pr2/io/rot13/).
|
||||
|
||||
Schreiben Sie eine Klasse `Rot13Reader`, die als Filter-Reader implementiert ist und jedes eingelesene Zeichen durch ein Zeichen ersetzt, dessen numerischer Wert um 13 höher ist (d.h. um 13 Schritte im Alphabet verschoben ist).
|
||||
|
||||
Schreiben Sie eine Klasse `Rot13`, die einen Dateinamen von der Kommandozeile nimmt und diese Text-Datei mithilfe von `Rot13Reader` liest und auf der Konsole ausgibt.
|
||||
|
||||
```console
|
||||
> cat /tmp/test
|
||||
DIES IST EIN TEXT, DER GLEICH ROT13 VERSCHLUESSELT WIRD.
|
||||
|
||||
> java Rot13 /tmp/test
|
||||
QVR`-V`a-RV[-aRea9-QR_-TYRVPU-_\a>@-cR_`PUYbR``RYa-dV_Q;
|
||||
```
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
# Datei zerhacken
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Daten byteweise aus einem Stream lesen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.scrambler](../sources/src/main/java/pr2/io/scrambler/).
|
||||
|
||||
Schreiben Sie eine Klasse `Scrambler`, die einen Dateinamen von der Kommandozeile entgegennimmt, die Datei einliest und dann wieder auf der Konsole ausgibt. Allerdings soll bei der Ausgabe nur jedes zweite Byte berücksichtigt werden.
|
||||
|
||||
```console
|
||||
> java Scrambler ../src/Scrambler.java
|
||||
motjv.oFlIpttem
|
||||
motjv.oFlNtonEcpin
|
||||
motjv.oIEcpin
|
||||
pbi ls cabe
|
||||
pbi ttcvi anSrn[ rs hosIEcpin{ i ag.egh! ){ Sse.r.rnl(
|
||||
Bteen ae nee"; Sse.xt1; }
|
||||
ienuSra i;
|
||||
r
|
||||
i e ienuSra(rs0)
|
||||
```
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Serialisierung
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Serialisierung einsetzen können, um Objekte zu persistieren und wieder zu laden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.io.serialisierung](../sources/src/main/java/pr2/io/serialisierung/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits eine fertig implementierte Klasse `Board` vor, die ein Schachbrett repräsentiert. Allerdings wird dieses nicht für Schach benutzt, sondern für ein Spiel, bei dem man nur schwarze und weiße Steine auf das Brett stellen kann (z.B. Dame). Die Farbe der Steine wird durch die Enumeration `Color` dargestellt.
|
||||
|
||||
Was bei dem Schachbrett allerdings noch fehlt, ist eine Möglichkeit den Spielstand zu speichern und später wieder einzulesen.
|
||||
|
||||
Schauen Sie sich die Klassen `Board` und `Color` genau an und versuchen Sie diese zu verstehen. Sie können auch testweise ein Brett anlegen und mit Daten befüllen. (Wie dies geht, sehen Sie im JUnit-Test). Die `toString()`-Methode liefert eine anschauliche Darstellung des Spielfeldes.
|
||||
|
||||
Implementieren Sie nun die Methoden `writeToFile` und `loadFromFile` unter Zuhilfenahme von Serialisierung. D.h. anders als in der Aufgabe zu `DataOutputStream`, sollen Sie hier kein eigenes Datenformat implementieren. Verwenden Sie stattdessen einen `ObjectOutputStream` bzw. `ObjectInputStream`.
|
||||
|
||||
Lassen Sie den JUnit-Test laufen, um zu sehen, ob die Daten korrekt verarbeitet 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`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# Einen generischen Typ schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen vorhandenen Typ so umgestalten, dass er als generischer Typ verwendet werden kann.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.einfach](../sources/src/main/java/pr2/generics/einfach/).
|
||||
|
||||
Sie finden mit `Liste` eine sehr simple Implementierung einer einfach verketteten Liste vor. Zusätzlich gib es auch noch Tests, die die Liste testen.
|
||||
|
||||
Führen Sie die Tests aus und überzeugen Sie sich, dass die Liste korrekt funktioniert.
|
||||
|
||||
Schreiben Sie die Klasse `Liste` so um, dass sie zu einem generischen Typ wird. Dies bedeutet insbesondere, dass die Methoden `get` und `add` nicht mehr mit `Object` arbeiten, sondern typsicher werden. Sie dürfen in Ihrer Lösung __keine Casts__ verwenden, d.h. Sie müssen sich auch mit der Klasse `ListNode` beschäftigen und hier Änderungen vornehmen.
|
||||
|
||||
Führen Sie die Tests erneut aus, um sicherzugehen, dass Sie bei Ihren Änderungen nichts kaputt gemacht haben.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Generische Klasse Pair schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Von einem generischen Typ erben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.pair](../sources/src/main/java/pr2/generics/pair/).
|
||||
|
||||
Schreiben Sie eine generische Klasse `Pair`, die zwei Objekte unterschiedlichen Typs verwalten kann. Die Instanzen von `Pair` sollen unveränderlich (**immutable**) sein.
|
||||
|
||||
Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Generische Klasse Pair erweitern: NumberPair
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Von einem generischen Typ erben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.number_pair](../sources/src/main/java/pr2/generics/number_pair/).
|
||||
|
||||
Schreiben Sie eine generische Klasse `NumberPair`, die von der Klasse `Pair` aus der vorhergehenden Aufgabe abgeleitet ist und erzwingt, dass beide verwaltete Objekte von `Number` oder einer Subklasse von `Number` (`Double`, `Integer`, `Long` etc.) sind.
|
||||
|
||||
Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Generische Klasse Pair erweitern: SamePair
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Von einem generischen Typ erben.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.same_pair](../sources/src/main/java/pr2/generics/same_pair/).
|
||||
|
||||
Schreiben Sie eine generische Klasse `SamePair`, die von der Klasse `Pair` aus der vorhergehenden Aufgabe abgeleitet ist und erzwingt, dass beide verwaltete Objekte vom selben Typ sind.
|
||||
|
||||
Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# PairList
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Sammlungen von Objekten eines generischen Typs erstellen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.pairlist](../sources/src/main/java/pr2/generics/pairlist/).
|
||||
|
||||
Schreiben Sie eine generische Klasse `PairList`, die eine beliebige Anzahl von `Pair`-Objekten verwalten kann. Die Anzahl der maximal gespeicherten Objekte wird beim Erzeugen mitgegeben. Die Klasse erlaubt das Hinzufügen (`add`) und das Auslesen von Objekten anhand des Indexes (`get`).
|
||||
|
||||
Testen Sie Ihre Implementierung mit der vorhandenen `Main`-Klasse.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Wildcard benutzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Wildcards einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.printer](../sources/src/main/java/pr2/generics/printer/).
|
||||
|
||||
Schreiben Sie eine Klasse `CollectionPrinter` mit einer statischen Methode `print`, der man eine beliebige (generische) Collection übergeben kann und die dann deren Inhalt ausdruckt. Eine _Collection_ ist eine Klasse, die beliebig viele Objekte verwalten kann und über die man mit der _for each_-Schleife iterieren kann.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Generische Queue
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen komplexeren generischen Typ entwickeln.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.queue](../sources/src/main/java/pr2/generics/queue/).
|
||||
|
||||
Schreiben Sie eine generische Klasse `Queue`, die eine einfache Warteschlange (Queue) realisiert. Über die Methode `offer` können Objekte hinzugefügt werden, über `poll` wieder ausgelesen. Über Probleme des Over- und Underflows brauchen Sie sich hier keine Gedanken zu machen.
|
||||
|
||||
Erweitern Sie die Klasse `Queue` um eine Methode `addAll`, der man eine andere `Queue` übergibt und die dann alle Elemente der übergebenen Queue in die aktuelle übernimmt.
|
||||
|
||||
Erweitern Sie die Klasse `Queue` aus der vorhergehenden Aufgabe um eine Methode `copyInto`, der man eine andere `Queue` übergibt und die dann alle Elemente der aktuellen Queue in die übergebenen kopiert.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
# `super` und `extends` einsetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Methoden unter Verwendung von `super` und `extends` gestalten, sodass sie flexibel auch mit Sub- bzw. Supertypen umgehen können.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.super_extends](../sources/src/main/java/pr2/generics/super_extends/).
|
||||
|
||||
In dieser Aufgabe sollen Sie die Klasse `Liste` erweitern.
|
||||
|
||||
Fügen Sie `Liste` zwei Methoden hinzu:
|
||||
|
||||
* `fillFrom`: befüllt die Liste mit den Daten aus einer anderen (übergebene) Liste.
|
||||
* `copyInto`: kopiert die Daten der Liste in eine andere (übergebene) Liste.
|
||||
|
||||
Verwenden Sie für Ihre Lösung `super` und `extends` zusammen mit Wildcards (`?`).
|
||||
|
||||
Kommentieren Sie die Testmethode in den vorhandenen Tests ein und führen Sie diese danach aus. Versichern Sie sich, dass Ihre Implementierung korrekt funktioniert, bevor Sie die Lösung abgeben.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# Generischen Typ verwenden
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Einen vorgegebenen generischen Typ einsetzen, um typsicher eine Menge von Objekten zu verwalten.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.verwenden](../sources/src/main/java/pr2/generics/verwenden/).
|
||||
|
||||
In dieser Aufgabe werden Sie ein einfaches Spiel implementieren, mit bei dem man einen Stapel Münzen möglichst schnell abräumen muss. Man nimmt eine Münze, indem man auf sie klickt. Jede Münze gibt dieselbe Anzahl von Punkten. Es geht also eher um das schnelle Klicken.
|
||||
|
||||
Die Münzen liegen als Stapel (_Stack_) vor, d.h. man kann immer nur die oberste Münze herunternehmen. Um dies in dem Spiel zu realisieren, sollen Sie den vorgefertigten, generischen Datentyp `Stack` verwenden, den Sie im Paket `java.util` finden.
|
||||
|
||||
Bei dieser Aufgabe sollen Sie _nicht_ die Klasse `GameBoard` generisch machen, sondern innerhalb der Klasse den `Stack` als generischen Typ verwenden.
|
||||
|
||||
Öffnen Sie die Klasse `GameBoard` und orientieren Sie sich bei Ihren Änderungen an den `TODO`-Kommentaren.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
# Generische Typen zusammen mit Wildcards einsetzen
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Gebundene und ungebundene Wildcards einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.generics.wildcards](../sources/src/main/java/pr2/generics/wildcards/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits eine Implementierung einer generischen, auf Arrays basierenden Liste namens `SimpleList` vor. An dieser müssen Sie nichts verändern, sondern verwenden die Klasse wie sie ist.
|
||||
|
||||
Schreiben Sie nun eine _nicht generische_ Klasse `ListHelper`, die zwei statische Methoden enthält:
|
||||
|
||||
* `printList`: Diese Methode bekommt eine beliebige `SimpleList` übergeben und druckt deren Inhalt einfach auf der Konsole aus. Deswegen hat die Methode auch den Rückgabetyp `void`.
|
||||
* `sumList`: Diese Methode nimmt als Parameter `SimpleList`-Objekte, die irgendeine Form von Zahlen enthalten (`Number` oder Subklassen davon) und berechnet deren Summe. Das Ergebnis wird als `double`-Wert zurückgegeben.
|
||||
|
||||
Verwenden Sie für die Methoden gebundene bzw. ungebundene Wildcards.
|
||||
|
||||
Kommentieren Sie die entsprechenden Zeilen in der Klasse `Main` aus und sehen überprüfen Sie, ob Ihre Implementierungen auch wie gewünscht funktionieren. Die Ausgabe sollte sein:
|
||||
|
||||
```console
|
||||
Dies
|
||||
ist
|
||||
ein
|
||||
Test
|
||||
.
|
||||
1
|
||||
2
|
||||
3
|
||||
4
|
||||
5
|
||||
15.0
|
||||
```
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Anonyme Klasse schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine anonyme Klasse verwenden, um einen Event-Handler zu implementieren. Den Zugriff der anonymen Klasse auf Attribute der umgebenden Klasse und finale Parameter der Methode nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
In dieser Aufgabe sollen Sie den Event-Handler für das Zerstören des Aliens als anonyme Klasse im Konstruktor von `GameBoard` realisieren. D.h. nicht mehr das Alien selbst reagiert auf das Klicken, sondern das `GameBoard` bekommt alle Klicks und überprüft, ob sich die Maus über dem Alien befindet.
|
||||
|
||||
Fügen Sie dem Konstruktor von `GameBoard` eine anonyme Klasse hinzu, die von `MouseAdapter` erbt. Überschreiben Sie in dieser Klasse die Methode `mousePressed` aus `MouseAdapter`.
|
||||
|
||||
In der `mousePressed`-Methode holen Sie die X- und Y-Koordinate aus dem `MouseEvent` und überprüfen Sie mit der Methode `intersects` von `Alien`, ob sich die Maus auch wirklich über dem Alien befindet. Wenn ja, rufen Sie die `explode`-Methode des Aliens auf.
|
||||
|
||||
Wenn sich der Mauszeiger nicht innerhalb des Aliens befindet, verschieben Sie das Alien (mit der Methode `setPosition`) an die Position des Mauszeigers.
|
||||
|
||||
Übergeben Sie die Instanz der anonymen Klasse der `addMouseListener`-Methode von `GameBoard`.
|
||||
|
||||
Lassen Sie das Programm laufen und überprüfen Sie, ob es das erwartete Verhalten zeigt.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Eigene compare-Methode schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Objekte vergleichen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.array_sorter](../sources/src/main/java/pr2/lambda/array_sorter/).
|
||||
|
||||
Schreiben Sie ein Java-Programm `ReverseSort`, das ein Array mit `Date`-Objekten erzeugt und dieses dann mithilfe der `Arrays.sort`-Methode in umgekehrter Reihenfolge sortiert. Um die umgekehrte Sortierung zu erhalten, erzeugen Sie bitte direkt im Aufruf der `sort`-Methode einen entsprechenden `Comparator` als anonyme innere Klasse.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Innere Klasse Beobachter
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Zugriff von inneren Klassen auf die umgebende Klasse.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket: [pr2.lambda.observer](../sources/src/main/java/pr2/lambda/observer/).
|
||||
|
||||
Dort finden Sie das Interface `Beobachter`.
|
||||
|
||||
Schreiben Sie eine Klasse `Datenhalter`, die eine einziges, privates Attribut vom Typ `int` enthält. Setzen Sie das Attribut im Konstruktor, erzeugen Sie aber keinen Getter.
|
||||
|
||||
Implementieren Sie das Interface `Beobachter` als nicht-statische, private innere Klasse in `Datenhalter` und erlauben Sie über den Beobachter Zugriff auf das Attribut, indem Sie ein entsprechendes Objekt vom Typ `Beobachter` zurückgeben. Testen Sie Ihre Implementierung mit einem JUnit-Test.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Callback mit anonymer Klasse realisieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine gegebene Funktion durch einen Callback parametrieren. Der Callback wird als anonyme innere Klasse realisiert.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.callback](../sources/src/main/java/pr2/lambda/callback/).
|
||||
|
||||
In dieser Aufgabe wird ein sehr gängiges Muster benutzt, dass auch bei großen Suchmaschinen zum Einsatz kommt. Über eine Filter-Funktion werden aus einer Menge von Daten diejenigen ausgewählt, die gewünscht sind. Die Auswahlfunktion wird von außen vorgegeben, sodass beliebige Filteroperationen möglich sind, auch solche, die beim Schreiben des Rahmenwerkes noch nicht bekannt waren.
|
||||
|
||||
Sehen Sie sich das Interface `Prediacte` und die Klasse `NumberSelector` an und versuchen Sie die Funktionsweise der beiden zu verstehen. Betrachten Sie nun die Klasse `Main`, die versucht zuerst die geraden und dann die ungeraden Zahlen auszuwählen und auszugeben. Der hierfür nötige Code ist zwar schon weitgehend vorhanden, aber in der `main`-Methode müssen Sie noch zwei passende Filterfunktionen als **anonyme innere Klassen** realisieren.
|
||||
|
||||
Nachdem Sie die beiden Filter geschrieben haben, lassen Sie das Programm laufen und überprüfen Sie, ob wirklich die richtigen Zahlen ausgewählt 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`.
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
# Comparator als Lambda
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Lambdas verwenden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket
|
||||
[pr2.lambda.comparator](../sources/src/main/java/pr2/lambda/comparator/).
|
||||
|
||||
Als Teil der Java-Klassenbibliothek findet sich das Interface `Comparator`, mit dem beim Sortieren eine Sortierreihenfolge vorgeben werden kann. Da es sich um ein funktionales Interface handelt, kann man es auch mit einem Lambda-Ausdruck implementieren. Schauen Sie sich den Aufbau des Interfaces in der JavaDoc an.
|
||||
|
||||
Sortieren Sie ein Array von Zahlen (repräsentiert als `Integer`, nicht als `int`) in _absteigender_ Reihenfolge mithilfe der Methode `sort` der Klasse `Arrays` und geben Sie ihr einen entsprechenden `Comparator` als Lambda-Ausdruck mit.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# Callback mit Lambda realisieren
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine gegebene Funktion durch einen Callback parametrieren. Der Callback wird als Lambda realisiert.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.lambdas](../sources/src/main/java/pr2/lambda/lambdas/).
|
||||
|
||||
In dieser Aufgabe wird ein sehr gängiges Muster benutzt, dass auch bei großen Suchmaschinen zum Einsatz kommt. Über eine Filter-Funktion werden aus einer Menge von Daten diejenigen ausgewählt, die gewünscht sind. Die Auswahlfunktion wird von außen vorgegeben, sodass beliebige Filteroperationen möglich sind, auch solche, die beim Schreiben des Rahmenwerkes noch nicht bekannt waren.
|
||||
|
||||
Sehen Sie sich das Interface `Predicate` und die Klasse `NumberSelector` an und versuchen Sie die Funktionsweise der beiden zu verstehen. Betrachten Sie nun die Klasse `Main`, die versucht zuerst die geraden und dann die ungeraden Zahlen auszuwählen und auszugeben. Der hierfür nötige Code ist zwar schon weitgehend vorhanden, aber in der `main`-Methode müssen Sie noch zwei passende Filterfunktionen als **Lambda** realisieren.
|
||||
|
||||
Nachdem Sie die beiden Filter geschrieben haben, lassen Sie das Programm laufen und überprüfen Sie, ob wirklich die richtigen Zahlen ausgewählt werden.
|
||||
|
||||
Vergleichen Sie die Lösung mit Lambdas mit der aus der vorhergehenden Aufgabe, die auf anonymen inneren Klassen basiert hat.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# Lokale Klasse schreiben
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine lokale Klasse verwenden, um einen Event-Handler zu implementieren. Den Zugriff der lokalen Klasse auf Attribute der umgebenden Klasse und finale Parameter der Methode nutzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.local](../sources/src/main/java/pr2/lambda/local/).
|
||||
|
||||
In dieser Aufgabe sollen Sie den Event-Handler für das Zerstören des Aliens als lokale Klasse im Konstruktor von `GameBoard` realisieren. D.h. nicht mehr das Alien selbst reagiert auf das Klicken, sondern das `GameBoard` bekommt alle Klicks und überprüft, ob sich die Maus über dem Alien befindet.
|
||||
|
||||
Fügen Sie dem Konstruktor von `GameBoard` eine lokale Klasse `AlienExploder` hinzu, die von `MouseAdapter` erbt. Überschreiben Sie in dieser Klasse die Methode `mousePressed` aus `MouseAdapter`.
|
||||
|
||||
In der `mousePressed`-Methode holen Sie die X- und Y-Koordinate aus dem `MouseEvent` und überprüfen Sie mit der Methode `intersects` von `Alien`, ob sich die Maus auch wirklich über dem Alien befindet. Wenn ja, rufen Sie die `explode`-Methode des Aliens auf.
|
||||
|
||||
Erzeugen Sie nach der Deklaration der Klasse `AlienExploder` eine Instanz von dieser und übergeben Sie das Objekt der `addMouseListener`-Methode von `GameBoard`.
|
||||
|
||||
Lassen Sie das Programm laufen und überprüfen Sie, ob es das erwartete Verhalten zeigt.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# MatrixSuche
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Statische innere Klassen einsetzen.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.matrixsuche](../sources/src/main/java/pr2/lambda/matrixsuche/).
|
||||
|
||||
Schreiben Sie eine Klasse `MatrixSuche`, die eine statische Methode `findEntry` anbietet. Die Methode soll in einem zweidimensionalen `int`-Array nach einem gegebenen Eintrag suchen und die Position des gefundenen Eintrags in der Matrix zurückgeben. Um die Position zurückzugeben, verwenden Sie bitte eine statische innere Klasse namens `Position`, die die x- und y-Postion enthält.
|
||||
|
||||
Überschreiben Sie die `toString`-Methode in `Position` und testen Sie, ob Ihre Implementierung richtig funktioniert.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
# StringTransmogrifier
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Funktionale Interfaces entwerfen und verwenden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.mogrifier_1](../sources/src/main/java/pr2/lambda/mogrifier_1/).
|
||||
|
||||
Schreiben Sie ein funktionales Interface namens `StringFunction`. Die Methode des Interfaces nimmt eine String und gibt einen String zurück.
|
||||
|
||||
Schreiben Sie eine Klasse `StringTransmogrifier`, die eine statische Methode `transmogrify` hat, der man ein String-Array und eine `StringFunction` übergibt. Die Methode wendet die Funktion auf jedes Element des Arrays an und gibt ein neues Array mit dem Ergebnis zurück.
|
||||
|
||||
Schreiben Sie eine Klasse `StringTransmogrifierTest`, die ein String-Array erzeugt und dann mithilfe der Klasse `StringTransmogrifier` die Elemente verändert. Nehmen Sie folgende Änderungen am Array vor, indem Sie entsprechende Lambda-Ausdrücke oder Methodenreferenzen übergeben:
|
||||
|
||||
* Umwandeln aller Buchstaben in Kleinbuchstaben.
|
||||
* Umwandeln aller Buchstaben in Großbuchstaben.
|
||||
* Ersetzen jedes Buchstaben durch den im Alphabet folgenden.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# StringTransmogrifier erweitern
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Funktionale Interfaces entwerfen und verwenden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.mogrifier_2](../sources/src/main/java/pr2/lambda/mogrifier_2/).
|
||||
|
||||
Ausgehend von der vorhergehenden Aufgabe, erweitern Sie das Interface `StringFunction` um eine _statische Methode_ namens `caesar`, mit der man sich eine `StringFunction` erzeugen lassen kann, die die Buchstaben des Strings um einen frei wählbaren Wert verschiebt.
|
||||
|
||||
Teste Sie Ihre Implementierung wieder mit `StringTransmogrifierTest`.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
# Nonstatic Member Class
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine nichtstatische Elementklasse verwenden.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.nonstatic](../sources/src/main/java/pr2/lambda/nonstatic/).
|
||||
|
||||
Wieder geht es um das einfache Spiel aus der ersten Aufgabe. Diesmal sollen Sie allerdings die Klasse `Alien` zu einer nichtstatischen Elementklasse von `GameBoard` machen. Achten Sie insbesondere darauf, dass sie nur noch die implizite Referenz `GameBoard.this` verwenden, um das Board innerhalb von `Alien` zu verwenden. Außerdem soll sich `Alien` im Konstruktor selbst als `MouseListener` registrieren, d.h. die entsprechende Zeile `addMouseListener(alien);` soll aus `GameBoard` verschwinden und in `Alien` verwendet werden.
|
||||
|
||||
Lassen Sie das Spiel wieder laufen und überprüfen Sie, ob es korrekt funktioniert.
|
||||
|
||||
|
||||
## 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`.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
# Static Member Class
|
||||
|
||||
|
||||
|
||||
## Lernziel
|
||||
|
||||
Eine Klasse als statische Elementklasse realisieren.
|
||||
|
||||
## Aufgabe
|
||||
|
||||
Gehen Sie in das Paket [pr2.lambda.static_member](../sources/src/main/java/pr2/lambda/static_member/).
|
||||
|
||||
In dieser Aufgabe finden Sie bereits ein voll funktionsfähiges Beispiel vor. Lassen Sie es laufen und machen Sie sich mit der Funktionsweise vertraut. (Das Spiel kennen Sie bereits aus einer vorhergehenden Aufgabe, nur die Grafik ist etwas anders.)
|
||||
|
||||
Ihre Aufgabe besteht nun darin, die Klasse `Alien` zu einer statischen Elementklasse der Klasse `GameBoard` zu machen.
|
||||
|
||||
Lassen Sie das Programm nach der Änderung wieder laufen und schauen überprüfen Sie, dass es sich noch korrekt verhält.
|
||||
|
||||
|
||||
## 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`.
|
||||
57
readme.md
57
readme.md
|
|
@ -7,7 +7,7 @@ Hier finden Sie die **freiwilligen Übungen** zur Vorlesung Programmieren 2 (PR2
|
|||
Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstattung.md).
|
||||
|
||||
| # | Ausgabe | Thema |
|
||||
|----|-------------------------------------------------------------------------|----------------|
|
||||
|----|---------------------------------------------------------------------------------------------|----------------|
|
||||
| 1. | 14.03.2023 | [String in Großbuchstaben umwandeln](Assignment_001/readme.md) |
|
||||
| 2. | 14.03.2023 | [Labeled Break](Assignment_002/readme.md) |
|
||||
| 3. | 14.03.2023 | [Passwortbewertung](Assignment_003/readme.md) |
|
||||
|
|
@ -38,3 +38,58 @@ Hinweise zur nötigen Softwareausstattung finden Sie [hier](help/softwareausstat
|
|||
| 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) |
|
||||
| 48. | 04.05.2023 | [`BufferedReader` zum zeilenweisen Lesen einsetzen](Assignment_048/readme.md) |
|
||||
| 49. | 04.05.2023 | [DataOutputStream](Assignment_049/readme.md) |
|
||||
| 50. | 04.05.2023 | [DataOutputStream durch Serialisierung ersetzen](Assignment_050/readme.md) |
|
||||
| 51. | 04.05.2023 | [Daten mit `DataOutputStream` und `DataInputStream` verarbeiten](Assignment_051/readme.md) |
|
||||
| 52. | 04.05.2023 | [Daten mit einem `InputStream` lesen](Assignment_052/readme.md) |
|
||||
| 53. | 04.05.2023 | [Daten mit einem `OutputStream` schreiben](Assignment_053/readme.md) |
|
||||
| 54. | 04.05.2023 | [Filesystem-Abstraktion mit `File`](Assignment_054/readme.md) |
|
||||
| 55. | 04.05.2023 | [Fileattribute lesen](Assignment_055/readme.md) |
|
||||
| 56. | 04.05.2023 | [`FilterReader`](Assignment_056/readme.md) |
|
||||
| 57. | 04.05.2023 | [Konsolen Input/Output](Assignment_057/readme.md) |
|
||||
| 58. | 04.05.2023 | [Zeilen einer Textdatei zählen](Assignment_058/readme.md) |
|
||||
| 59. | 04.05.2023 | [`RandomAccessFile`](Assignment_059/readme.md) |
|
||||
| 60. | 04.05.2023 | [`Reader` verwenden](Assignment_060/readme.md) |
|
||||
| 61. | 04.05.2023 | [Rot13-Verschlüsselung](Assignment_061/readme.md) |
|
||||
| 62. | 04.05.2023 | [Datei zerhacken](Assignment_062/readme.md) |
|
||||
| 63. | 04.05.2023 | [Serialisierung](Assignment_063/readme.md) |
|
||||
| 64. | 22.05.2023 | [Einen generischen Typ schreiben](Assignment_064/readme.md) |
|
||||
| 65. | 22.05.2023 | [Generische Klasse Pair schreiben](Assignment_065/readme.md) |
|
||||
| 66. | 22.05.2023 | [Generische Klasse Pair erweitern: NumberPair](Assignment_066/readme.md) |
|
||||
| 67. | 22.05.2023 | [Generische Klasse Pair erweitern: SamePair](Assignment_067/readme.md) |
|
||||
| 68. | 22.05.2023 | [PairList](Assignment_068/readme.md) |
|
||||
| 69. | 22.05.2023 | [Wildcard benutzen](Assignment_069/readme.md) |
|
||||
| 70. | 22.05.2023 | [Generische Queue](Assignment_070/readme.md) |
|
||||
| 71. | 22.05.2023 | [`super` und `extends` einsetzen](Assignment_071/readme.md) |
|
||||
| 72. | 22.05.2023 | [Generischen Typ verwenden](Assignment_072/readme.md) |
|
||||
| 73. | 22.05.2023 | [Generische Typen zusammen mit Wildcards einsetzen](Assignment_073/readme.md) |
|
||||
| 74. | 05.06.2023 | [Anonyme Klasse schreiben](Assignment_074/readme.md) |
|
||||
| 75. | 05.06.2023 | [Eigene compare-Methode schreiben](Assignment_075/readme.md) |
|
||||
| 76. | 05.06.2023 | [Innere Klasse Beobachter](Assignment_076/readme.md) |
|
||||
| 77. | 05.06.2023 | [Callback mit anonymer Klasse realisieren](Assignment_077/readme.md) |
|
||||
| 78. | 05.06.2023 | [Comparator als Lambda](Assignment_078/readme.md) |
|
||||
| 79. | 05.06.2023 | [Callback mit Lambda realisieren](Assignment_079/readme.md) |
|
||||
| 80. | 05.06.2023 | [Lokale Klasse schreiben](Assignment_080/readme.md) |
|
||||
| 81. | 05.06.2023 | [MatrixSuche](Assignment_081/readme.md) |
|
||||
| 82. | 05.06.2023 | [StringTransmogrifier](Assignment_082/readme.md) |
|
||||
| 83. | 05.06.2023 | [StringTransmogrifier erweitern](Assignment_083/readme.md) |
|
||||
| 84. | 05.06.2023 | [Nonstatic Member Class](Assignment_084/readme.md) |
|
||||
| 85. | 05.06.2023 | [Static Member Class](Assignment_085/readme.md) |
|
||||
|
|
|
|||
|
|
@ -0,0 +1,52 @@
|
|||
package pr2.enums.eigene;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* Ein einfacher Würfel.
|
||||
*/
|
||||
public class Wuerfel {
|
||||
|
||||
/** 4-seitiger Würfel. */
|
||||
public static final int D4 = 4;
|
||||
|
||||
/** 6-seitiger Würfel. */
|
||||
public static final int D6 = 6;
|
||||
|
||||
/** 8-seitiger Würfel. */
|
||||
public static final int D8 = 8;
|
||||
|
||||
/** 10-seitiger Würfel. */
|
||||
public static final int D10 = 10;
|
||||
|
||||
/** 12-seitiger Würfel. */
|
||||
public static final int D12 = 13;
|
||||
|
||||
/**
|
||||
* Zufallszahlengenerator.
|
||||
*/
|
||||
private final Random rnd = new Random();
|
||||
|
||||
/**
|
||||
* Anzahl der Seiten des Würfels.
|
||||
*/
|
||||
private final int numSides;
|
||||
|
||||
/**
|
||||
* Einen neuen Würfel anlegen.
|
||||
*
|
||||
* @param typ Anzahl der Seiten des Würfels.
|
||||
*/
|
||||
public Wuerfel(int numSides) {
|
||||
this.numSides = numSides;
|
||||
}
|
||||
|
||||
/**
|
||||
* Den Würfel werfen.
|
||||
*
|
||||
* @return Ergebnis des Wurfes.
|
||||
*/
|
||||
public int roll() {
|
||||
return rnd.nextInt(numSides) + 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
package pr2.enums.eigene.test;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import pr2.enums.eigene.Wuerfel;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/**
|
||||
* Test für die Würfel.
|
||||
*/
|
||||
public class WuerfelTest {
|
||||
|
||||
/**
|
||||
* Anzahl der Durchläufe (Gesetz der großen Zahl!).
|
||||
*/
|
||||
private static final int RUNS = 10000000;
|
||||
|
||||
|
||||
@Test
|
||||
void testFairnessD4() {
|
||||
internalTestFairness(new Wuerfel(Wuerfel.D4), 2.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFairnessD6() {
|
||||
internalTestFairness(new Wuerfel(Wuerfel.D6), 3.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFairnessD8() {
|
||||
internalTestFairness(new Wuerfel(Wuerfel.D8), 4.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFairnessD10() {
|
||||
internalTestFairness(new Wuerfel(Wuerfel.D10), 5.5);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFairnessD12() {
|
||||
internalTestFairness(new Wuerfel(Wuerfel.D12), 6.5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Interne Hilfsmethode, um die Fairness zu testen.
|
||||
*
|
||||
* @param w der zu testende Wuerfel.
|
||||
* @param expected Erwartungswert.
|
||||
*/
|
||||
private void internalTestFairness(Wuerfel w, double expected) {
|
||||
long sum = 0;
|
||||
|
||||
for (int i = 0; i < RUNS; i++) {
|
||||
sum += w.roll();
|
||||
}
|
||||
double average = (double) sum / (double) RUNS;
|
||||
assertEquals(expected, average, 0.1);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.enums.filme;
|
||||
|
||||
public enum LieblingsFilme {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
package pr2.enums.filme;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
// TODO: Alle Filme ausgeben
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
package pr2.enums.schnick;
|
||||
|
||||
public enum Move {
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
package pr2.enums.schnick;
|
||||
|
||||
import java.util.Random;
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Schick - Schnack - Schnuck (Rock - Paper - Scissors).
|
||||
*/
|
||||
public class SchnickSchnackSchnuck {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
package pr2.enums.singleton;
|
||||
|
||||
enum MyEnum {
|
||||
A,
|
||||
B,
|
||||
C;
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
package pr2.enums.singleton;
|
||||
|
||||
public class SingletonBeweis {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO: Singleton-Eigenschaft zeigen
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package pr2.enums.verwenden;
|
||||
|
||||
import de.smits_net.games.framework.board.Board;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.Point;
|
||||
|
||||
/**
|
||||
* Spielfeld.
|
||||
*/
|
||||
public class GameBoard extends Board {
|
||||
|
||||
/**
|
||||
* Sprite, das durch das Bild läuft.
|
||||
*/
|
||||
private final Professor sprite;
|
||||
|
||||
/**
|
||||
* Erzeugt ein neues Board.
|
||||
*/
|
||||
public GameBoard() {
|
||||
// neues Spielfeld anlegen
|
||||
super(10, new Dimension(400, 400), Color.BLACK);
|
||||
|
||||
// Sprite initialisieren
|
||||
sprite = new Professor(this, new Point(300, 200));
|
||||
}
|
||||
|
||||
/**
|
||||
* Spielfeld neu zeichnen. Wird vom Framework aufgerufen.
|
||||
*/
|
||||
@Override
|
||||
public void drawGame(Graphics g) {
|
||||
sprite.draw(g, this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Spielsituation updaten. Wird vom Framework aufgerufen.
|
||||
*/
|
||||
@Override
|
||||
public boolean updateGame() {
|
||||
sprite.move();
|
||||
return sprite.isVisible();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package pr2.enums.verwenden;
|
||||
|
||||
import de.smits_net.games.framework.board.MainWindow;
|
||||
|
||||
import java.awt.EventQueue;
|
||||
|
||||
/**
|
||||
* Hauptklasse des Spiels.
|
||||
*/
|
||||
public class GameMain extends MainWindow {
|
||||
|
||||
/**
|
||||
* Neues Spiel anlegen.
|
||||
*/
|
||||
public GameMain() {
|
||||
super("Watch me walk...", new GameBoard());
|
||||
}
|
||||
|
||||
/**
|
||||
* Startpunkt.
|
||||
*
|
||||
* @param args command line arguments.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
// Spiel starten
|
||||
EventQueue.invokeLater(GameMain::new);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package pr2.enums.verwenden;
|
||||
|
||||
import de.smits_net.games.framework.board.Board;
|
||||
import de.smits_net.games.framework.image.AnimatedImage;
|
||||
import de.smits_net.games.framework.sprite.AnimatedSprite;
|
||||
import de.smits_net.games.framework.sprite.Direction;
|
||||
|
||||
import java.awt.Point;
|
||||
|
||||
/**
|
||||
* Ein Sprite.
|
||||
*/
|
||||
public class Professor extends AnimatedSprite {
|
||||
|
||||
/**
|
||||
* Geschwindigkeit der Figur in X-Richtung.
|
||||
*/
|
||||
private static final int SPRITE_SPEED = 2;
|
||||
|
||||
/**
|
||||
* Neues Sprite anlegen.
|
||||
*
|
||||
* @param board das Spielfeld
|
||||
* @param startPoint Start-Position
|
||||
*/
|
||||
public Professor(Board board, Point startPoint) {
|
||||
super(board, startPoint, BoundaryPolicy.NONE,
|
||||
new AnimatedImage(50, 9,
|
||||
"pr2/enums/use/professor_left"));
|
||||
velocity.setVelocity(Direction.WEST, SPRITE_SPEED);
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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.
|
||||
}
|
||||
|
|
@ -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);
|
||||
// });
|
||||
// }
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.exceptions.fakultaet;
|
||||
|
||||
public class FakultaetException {
|
||||
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
package pr2.generics.einfach;
|
||||
|
||||
/**
|
||||
* Eine einfache, verkettete Liste.
|
||||
*
|
||||
* @param <T> Typ der gespeicherten Objekte
|
||||
*/
|
||||
/**
|
||||
* Eine einfache, verkettete Liste.
|
||||
*/
|
||||
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(Object 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 Object 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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
package pr2.generics.einfach;
|
||||
|
||||
/**
|
||||
* Interne Repräsentation der Knoten in der Liste.
|
||||
*/
|
||||
class ListeNode {
|
||||
|
||||
/** Daten. */
|
||||
Object data;
|
||||
|
||||
/** Referenz auf den nächsten Knoten. */
|
||||
ListeNode next;
|
||||
|
||||
/**
|
||||
* Legt einen neuen Knoten an.
|
||||
*
|
||||
* @param data daten, die gespeichert werden
|
||||
*/
|
||||
ListeNode(Object data) {
|
||||
this.data = data;
|
||||
}
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package pr2.generics.number_pair;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
// TODO: Einkommentieren
|
||||
// var note = new Pair<String, Integer>("Peter", 1);
|
||||
// var name = new Pair<String, String>("Peter", "Meier");
|
||||
// var tel = new NumberPair<Integer>(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());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.generics.number_pair;
|
||||
|
||||
public class NumberPair {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package pr2.generics.number_pair;
|
||||
|
||||
public class Pair<T, V> {
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
package pr2.generics.pair;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
// TODO: Einkommentieren
|
||||
// var note1 = new Pair<String, Integer>("Peter", 1);
|
||||
// var note2 = new Pair<String, Integer>("Frank", 3);
|
||||
// var note3 = new Pair<String, Integer>("Sabine", 1);
|
||||
//
|
||||
// var name = new Pair<String, String>("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());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.generics.pair;
|
||||
|
||||
public class Pair {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package pr2.generics.pairlist;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
// TODO: Einkommentieren
|
||||
// var note1 = new Pair<String, Integer>("Peter", 1);
|
||||
// var note2 = new Pair<String, Integer>("Frank", 3);
|
||||
// var note3 = new Pair<String, Integer>("Sabine", 1);
|
||||
//
|
||||
// var pl = new PairList<String, Integer>(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());
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package pr2.generics.pairlist;
|
||||
|
||||
public class Pair<T, V> {
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.generics.pairlist;
|
||||
|
||||
public class PairList {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
package pr2.generics.printer;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
public class CollectionPrinter {
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
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) {
|
||||
// TODO: Einkommentieren
|
||||
// List<String> ls = new ArrayList<>();
|
||||
// List<Integer> li = new ArrayList<>();
|
||||
// ls.add("PR2");
|
||||
// ls.add("ist");
|
||||
// ls.add("cool");
|
||||
// Set<String> s = new HashSet<>(ls);
|
||||
// li.add(23);
|
||||
// li.add(42);
|
||||
//
|
||||
// CollectionPrinter.print(ls);
|
||||
// CollectionPrinter.print(li);
|
||||
// CollectionPrinter.print(s);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
package pr2.generics.queue;
|
||||
|
||||
public class Queue {
|
||||
|
||||
// TODO: Klasse gemäß der Aufgabenstellung implementieren
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
package pr2.generics.same_pair;
|
||||
|
||||
public class Main {
|
||||
public static void main(String[] args) {
|
||||
// TODO: Einkommentieren
|
||||
// var note = new Pair<String, Integer>("Peter", 1);
|
||||
// var name = new SamePair<String>("Peter", "Meier");
|
||||
// var tel = new SamePair<Integer>(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());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
package pr2.generics.same_pair;
|
||||
|
||||
public class Pair<T, V> {
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
package pr2.generics.same_pair;
|
||||
|
||||
public class SamePair {
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
package pr2.generics.super_extends;
|
||||
|
||||
/**
|
||||
* Eine einfache, verkettete Liste.
|
||||
*
|
||||
* @param <T> Typ der gespeicherten Objekte
|
||||
*/
|
||||
public class Liste<T> {
|
||||
|
||||
/**
|
||||
* Referenz auf den ersten Knoten.
|
||||
*/
|
||||
private ListeNode<T> first;
|
||||
|
||||
/**
|
||||
* Referenz auf den aktuellen Knoten.
|
||||
*/
|
||||
private ListeNode<T> current;
|
||||
|
||||
/**
|
||||
* Fügt ein neues Element an das Ende der Liste an.
|
||||
*
|
||||
* @param data das Element
|
||||
*/
|
||||
public void add(T data) {
|
||||
|
||||
ListeNode<T> 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<T> 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<T> 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.
|
||||
*/
|
||||
// TODO: copyInto implementieren
|
||||
|
||||
/**
|
||||
* Füllt diese Liste mit dem Inhalt der übergebenen Liste.
|
||||
*
|
||||
* @param other die andere Liste.
|
||||
*/
|
||||
// TODO: fillFrom implementieren
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue