Skip to main content

Übersicht zur inhaltlichen Ausgestaltung der Hausübungen

Allgemeiner Hinweis an alle, die an der Erstellung der Hausübungen beteiligt sind:

Gerne gebe ich zu Verständnisfragen Auskunft.

Außerdem: Letztendlich ist nichts in Stein gemeißelt, alles kann mit mir diskutiert werden – muss aber auch mit mir (Karsten Weihe) diskutiert werden. Das heißt, Abweichungen von den Vorgaben unten sind prinzipiell möglich, aber nur im vorherigen Einvernehmen mit mir.

Wichtig für alle Hausübungen:

  1. Die FOP ist unser Seepferdchenkurs!

Vollerhebungen in früheren Jahren ergaben: ca. 1/3 hat noch nicht einmal das Seepferdchen; ca. 1/3 hat Seepferdchen, aber nicht Freischwimmer. Daraus ergibt sich eine goldene Regel für alle Hausübungen:

Beim Design der Hausübungen sollten nicht „coole“ Anwendungen im Vordergrund stehen, sondern die umfassende Einübung der Basics. Insbesondere sollten die einzuübenden Konzepte systematisch in ihren verschiedenen Ausprägungen und in Kombination mit anderen, schon früher eingeführten Konzepten eingeübt werden. Im Zweifelsfall verzichtet man besser auf „coole“ Anwendungen.

  1. Für „Seepferdchen“ sollte der Aufwand pro Hausübung auch bei Einzelabgabe machbar bleiben.

  2. Der Aufwand zur Erstellung der Hausübungsblätter, der Referenzlösungen, der Bewertungskriterien, der Tests usw. muss aus naheliegenden Gründen überschaubar gehalten werden. Daraus ergibt sich eine zweite goldene Regel für alle Hausübungen:

Hausübung Nr. XY in Wintersemester 202Z/202(Z+1) sollte gerade soweit von Hausübung Nr. XY in Wintersemester 202(Z-1)/202Z abweichen, dass von Referenzlösung, Bewertungskriterien, Tests usw. für erstere nicht auf mögliche Lösungen für letztere geschlossen werden kann.

Textbausteine können gerne wörtlich übernommen werden, soweit sinnvoll (z.B. die Rubriken „Verständnisfragen“ und „Fehlermeldungen besser verstehen“ sollten in der Regel mit leichten Anpassungen übernommen werden können).

Querschnittsfunktionalitäten (X = must have, x = very nice to have):

0001020304050607080910111213
TestenXXXXXXXXXXXX
JUnitXXXXX
JavadocXXXXXXXXXXX
ohne FopBotXXXXXXXXX
ArraysXxxxxxxxxxxx
ExceptionsXxxxxx
Lambda-AusdrückeXxxxxxx
GenerizitätXXxxx
Public TestsXXXXX
Sanity TestsXXXXXxxxxx
Gesamtpunktzahlen der Übungsblätter
Übung0001020304050607080910111213
Gesamtpunkte416323232323232323232323232

Inhalte der Hausübungen im Einzelnen:

Struktur: <<Nr. der Hausübung>> – <<einzuübende Foliensätze>>: <<einzuübende Themen>>

00 – 01a: einfache Aktionen mit Robot aus FopBot, for- und while-Schleifen (Achtung: Foliensatz 01a behandelt noch nicht if-Verzweigungen!). Mehrere Verweise auf denselben Robot, ein Verweis nacheinander auf mehrere Robots.

01 – 01a und 01b: if, while und for; ineinander geschachtelte Schleifen (auch for und while gemischt); nichttriviale Initialisierung vor Schleifen; ineinander geschachtelte if-Verzweigungen; if-Kaskade (z.B. mit den vier Richtungen); Variable von Robot, int (auch außerhalb for-Kopf) und Direction; selbst Endlosschleifen in Rubrik „Verständnisfragen“ basteln.

02 – 01a-01d: ab jetzt systematisches Testen; Arrays und Arrays von Arrays von mindestens zwei verschiedenen Typen; Initialisierung, Lesen und Überschreiben einzelner Komponenten; Basismodifikationen auf den Komponenten von Arrays (Vertauschen von zwei und drei Komponentenwerten u.ä., vielleicht sogar Shift, Shift-Rotate oder Spiegelung des Arrays); systematisches Testen.

03 – 01e und 01f: ab jetzt systematisch Javadoc; Subtypen von Robot mit Konstruktor, zusätzlichen Attributen (auch von Referenztypen); mit überschriebenen, vererbten (also nicht überschrieben) Methoden; Methodenüberladung; ganz neue Klasse ohne extends-Klausel (z.B. eine Klasse, die ein oder mehrere Robot als Attribute hat) und Subtypen davon; Bedingungsoperator (z.B. in super im Konstruktor).

04 – 01g: Interfaces und Erweiterungen von Interfaces selbst schreiben; Klassen (mit und ohne Robot), die extends-Klausel plus implements-Klausel mit mehreren Interfaces haben;

05 – 03a und 03b: Inhalte wie 04, aber ganz ohne FopBot (also anderer Anwendungsfall); gerne wenn möglich auch Inhalte der Hausübungen 01-03 dabei nochmals aufgreifen.

06 – 03c, 04a und Anfang 04b (erste ca. 40-50 Folien): Denselben Racket-Code äquivalent rekursiv und iterativ in Java übersetzen: auf Zahlen und auf Listen (Arrays in Java); noch einmal if-Verzweigung und Bedingungsoperator fordern; Rekursion in Hilfsmethode auslagern, um eine geeignete Parameterliste für die Rekursion zu erhalten; Endlos-Rekursionen selbst basteln in Rubrik „Verständnisfragen“.

07 – 04b und 04c: Mindestens zwei verschiedene Functional Interfaces selbst schreiben; diese Interfaces implementierende Klassen vs äquivalente Lambda-Ausdrücke; Lambda-Ausdrücke in Kurz- und Standardform; möglichst auch Lambda-Ausdrücke in den Tests; Array von Lambda-Ausdrücken.

08 – 05 (ohne JUnit): assert in Methoden; assert ersetzen durch RuntimeException; selbst Exception-Klassen definieren; Array mit Exception-Klasse als Komponententyp; Exceptions werfen, fangen und weiterreichen.

09 – 05 (JUnit) und 06: ab jetzt Testen mit JUnit-Tests; generische Klassen, Interfaces und Ojektmethoden; Restricted Genericity bei Klassen/Interfaces und bei Objektmethoden; Klassenmethoden von generischen Klassen; In- und Outparameter mit Wildcards.

10 – 07: Listenoperationen auf Klasse ListItem<T> aus Foliensatz 07 (Collections); auch listenverändernde Operationen: dieselben Operationen einmal mit Umordnung in-place und einmal mit neuen ListItem-Objekte mit new zum Vergleich; Listenoperationen, die mehrere Input- und/oder Output-Listen haben.

11 – 08 (erster Teil: Streams): Intermediäre und terminale Operationen mit Stream<T> zu Ketten zusammengefügt; Streamoperationen, die mehrere Input- und/oder Output-Streams haben, selbst implementieren; unendliche Streams selbst implementieren.

12 – 08 (zweiter Teil: Files): Bytedaten und char-Daten einlesen und hinausschreiben, LineReader; Stream von Input-File; tabellarisch strukturierte Daten hinausschreiben und wieder einlesen.

13 – 10 (momentan angesagt: JavaFX): Öffnen und einfache Manipulationen von Fenstern (z.B. Ikonifizieren); mindestens zwei Komponentenarten (z.B. Button und Canvas); mit Layout-Manager arbeiten; eigene Listener-Klassen.

Back to top