Lektionen

Praxis der Lambda-Ausdrücke in Collections und Stream API: wie man anonyme Klassen durch kompakte Lambdas ersetzt, die Methoden der Collections nutzt ( forEach, removeIf, sort, replaceAll) und Verarbeitungspipelines aufbaut ( stream → filter → map → sorted → collect). Wir vergleichen mit anonymen Klassen, besprechen „effektiv final“-Variablen, führen eine Tabelle der wichtigsten Operationen auf und analysieren typische Fehler.

In der Vorlesung klären wir, warum Java Lambda-Ausdrücke bekommen hat: Kürze und Lesbarkeit, das Übergeben von Verhalten als Parameter, Integration mit Collections und Stream-API ( filter, map, forEach), das Einfangen „effektiv“ finaler Variablen und die bequeme Notation von Callbacks über den Operator ->. Parallel betrachten wir Fallstricke: Debugging langer Ketten, Mehrdeutigkeit bei Überladungen ( Runnable vs Callable), Einschränkungen von Closures, Serialisierung und verschachtelte Lambdas. Am Ende – praktische Empfehlungen, wann man Lambdas verwendet, und eine Analyse typischer Fehler.

In der Vorlesung besprechen wir, was ein Closure ist und wie es in Java funktioniert: wie Lambdas und anonyme Klassen externe Variablen „erfassen“, warum lokale Variablen final oder effektiv final sein müssen, worin sich das Erfassen lokaler Variablen vom Zugriff auf Klassenfelder unterscheidet, und wie sich this in Lambdas und anonymen Klassen verhält. Wir zeigen Funktionsfabriken mit IntSupplier, betrachten die interne Implementierung des Captures und typische Fehler (zum Beispiel die Compiler-Meldung Variable used in lambda expression should be final or effectively final).

In dieser Vorlesung erklären wir, was eine anonyme Klasse in Java ist und wie sie sich vom Lambda-Ausdruck unterscheidet: Syntax, Möglichkeiten (Felder, zusätzliche Methoden, Überschreiben von toString/ equals), Gültigkeitsbereich und Verhalten von this, Variablen-Capture (nur final/„effektiv final“). Es werden praktische Beispiele mit Runnable, Comparator, Predicate gezeigt sowie Empfehlungen – wann man eine Lambda wählt und wann eine anonyme Klasse.

Wir beleuchten die wichtigsten funktionalen Schnittstellen aus dem Paket java.util.function: Predicate, Consumer, Supplier, Function – was sie annehmen/zurückgeben und wo sie im Stream-API eingesetzt werden ( filter, map, forEach, generate). Wir erinnern an die Regel „genau eine abstrakte Methode“ und die Annotation @FunctionalInterface, schreiben Lambdas, vergleichen mit anonymen Klassen, üben am Beispiel mit der Klasse User und besprechen typische Fehler bei der Wahl zwischen Predicate/ Function u. a.

Diese Vorlesung handelt davon, wie man mit Function und ihren Methoden compose und andThen Verarbeitungspipelines aus kleinen Funktionen zusammensetzt. Wir klären die Ausführungsreihenfolge, die Typverträglichkeit, Beispiele mit Predicate ( and, or, negate), Consumer ( andThen), bauen praxisnahe Pipelines und besprechen typische Fehler: vertauschte Reihenfolge ( f.compose(g) vs f.andThen(g)), inkompatible Typen und Spaghetti-Code in Ketten. Sie lernen, apply, test, accept anzuwenden und lesbare, wiederverwendbare Transformationen zu bauen.

Praktische Einführung in die Übergabe von Verhalten in Java: wie man Lambda-Ausdrücke ( ->) und Methodenreferenzen ( ::) zusammen mit dem Stream-API und Collections verwendet. Wir besprechen die standardmäßigen funktionalen Interfaces aus java.util.function — Comparator, Predicate, Function, Consumer, Supplier — lernen, universelle Methoden zu schreiben, Verhalten als Parameter zu übergeben und typische Fehler zu vermeiden. Wir üben an Beispielen mit Stream, Optional und eigenen Hilfsfunktionen zur Listenverarbeitung.

Vom imperativen Schleifenstil zu deklarativen Datenverarbeitungspipelines mit der Stream-API: Wir besprechen Zwischen- und Terminaloperationen, Trägheit der Ausführung, das Sammeln von Ergebnissen via toList()/ collect, Schlüsseloperationen wie map, filter, sorted, flatMap, reduce sowie Prüfungen mit anyMatch/ allMatch/ noneMatch. Wir vergleichen imperativen und funktionalen Stil, betrachten Praxisbeispiele und typische Fehler, darunter ein unpassendes forEach beim Sammeln in Kollektionen und ein verfrühtes parallelStream().

Die 10 häufigsten Fehler im Umgang mit Lambdas und dem Stream-API in Java: Capture von Variablen ( final/ effectively final), das Verhalten von this in Lambdas, Side Effects und Parallelität ( parallelStream()), Typinferenz und generics, Umgang mit null und Optional, Funktionskomposition ( compose/ andThen) sowie Checked Exceptions (z. B. IOException). Wir zeigen sichere Praktiken: Filtern mit Objects::nonNull, Terminaloperationen ( sum(), collect(...)), thread‑sichere Collections und die Dekomposition langer Ketten.

Wie das Ereignismodell in Java funktioniert: Die Quelle erzeugt ein Ereignis, und die abonnierten Listener erhalten eine Benachrichtigung und reagieren darauf. Wir besprechen die wichtigsten Listener-Schnittstellen aus Swing – ActionListener, MouseListener, KeyListener, ChangeListener, DocumentListener – und zeigen, wie man Handler über addActionListener registriert und die Methode actionPerformed implementiert. Wir üben, Listener an JButton/ JFrame anzuschließen, vergleichen anonyme Klassen und Lambda-Ausdrücke und besprechen typische Fehler sowie praktische Tipps.

Kurze praxisnahe Einführung in das Ereignismodell AWT/ Swing: Wir erstellen eine Schaltfläche JButton, registrieren einen Listener über addActionListener und verarbeiten im actionPerformed. Wir behandeln anonyme Klassen und Lambda-Ausdrücke, gängige Listener ( MouseListener/ MouseAdapter, KeyAdapter, DocumentListener), schreiben eine Mini-Anwendung auf Basis von JFrame, JButton, JLabel, betrachten die Aufrufreihenfolge und typische Fehler (aufwändige Arbeit im Handler, Finalität von Variablen in Lambdas, vergessener addActionListener, Entfernen von Listenern, Einsatz von SwingWorker).

In dieser Vorlesung besprechen wir, wie man eigene Ereignisse in Java entwirft: Wir erstellen eine Ereignisklasse auf Basis von java.util.EventObject, definieren ein Listener-Interface über java.util.EventListener, fügen einen Mechanismus zum Abonnieren/Abmelden ( add...Listener/ remove...Listener) sowie zur Benachrichtigung ( fire...) hinzu. Wir schauen uns Praxisbeispiele mit DataLoader und einem Zähler an, diskutieren Handler mit anonymen Klassen und Lambda-Ausdrücken und gehen typische Fehler durch (Ausnahmen in Listenern, Memory-Leaks, ConcurrentModificationException).