Lektionen

Praktischer Leitfaden zum Aufbau von Klassenhierarchien in Java: von der Abstraktion zu den Details. Anhand von Beispielen mit Figuren, einem Mini‑Editor, Zahlungen und Transport zeigen wir, wie man Gemeinsames in eine Basis‑ abstract-Klasse auslagert, Methoden wie area()/ draw() überschreibt, das System ohne Neuschreiben von Code erweitert und Duplikate vermeidet. Wir schließen mit einem Überblick über typische Fehler und Gestaltungstipps.

Wir üben den Einsatz von Abstraktionen in realen Szenarien: Zahlungen, Transport, Grafikeditor. Wir zeigen, wie man gemeinsames Verhalten in eine grundlegende abstract-Klasse auslagert, über einen gemeinsamen Vertrag arbeitet und „verzweigten“ if- else-Code durch Polymorphismus ersetzt. Unterwegs sehen wir, wie man Methoden wie process(), move(), draw()/ resize() einheitlich aufruft, damit der Code flexibel und erweiterbar bleibt.

Wie man komplexe Anwendungen in Abstraktionsebenen (UI, Geschäftslogik, Datenzugriff) zerlegt, damit der Code verständlich und erweiterbar bleibt. In der Praxis bauen wir einen kleinen Task‑Manager mit den Schichten Task, TaskRepository, TaskService, zeigen den Austausch von Implementierungen und Vorteile für das Team. Wir besprechen Best Practices, typische Fehler und ein Beispiel mit den Services OrderService/ OrderRepository sowie Methoden wie saveOrder() und findUserById().

In dieser Vorlesung erfahren Sie, was ein Interface in Java ist, wie man es mit dem Schlüsselwort interface deklariert, wie Klassen den Vertrag über implements erfüllen und warum Methoden standardmäßig als public abstract gelten. Wir beleuchten die Unterschiede zwischen Interface und Klasse, Beispiele aus dem JDK ( Comparable, Runnable, Serializable), ein Schaubild und typische Fehler.

In dieser Vorlesung vergleichen wir Schnittstellen und abstrakte Klassen in Java: wann man was wählt, worin sie sich in Möglichkeiten und Einschränkungen unterscheiden, wie ihre Signaturen aussehen ( abstract class und interface), was Modifizierer wie public, abstract, static bedeuten, und wir betrachten Beispiele aus dem JDK, Praxisfälle und typische Fehler (Vererbung, Implementierung, Verwendung von implements/ extends).

In dieser Vorlesung besprechen wir, wie eine einzige Klasse in Java mehrere Interfaces gleichzeitig implementieren kann: die Syntax mit dem Schlüsselwort implements, die Kombination von Rollen (zum Beispiel Movable, Attackable, Serializable), identische Methodensignaturen, das Ausbleiben des „Diamantproblems“ sowie den Umgang mit Konflikten zwischen default-Methoden. Es gibt praktische Beispiele und eine Analyse typischer Fehler.

In der Vorlesung behandeln wir, was eine funktionale Schnittstelle ist (genau eine abstrakte Methode), wie und warum man sie mit der Annotation @FunctionalInterface kennzeichnet, womit eine Schnittstelle per default- und static-Methoden ergänzt werden darf und wie solche Schnittstellen in der Praxis angewendet werden (normale Klassen und anonyme Klassen). Beispiele mit Runnable, Comparator<T> und Schnittstellen aus java.util.function werden durch eine Tabelle und die Analyse typischer Fehler ergänzt.

Wie Schnittstellen Code in eine flexible Architektur verwandeln: Wir programmieren gegen Abstraktionen, injizieren Abhängigkeiten via DI, ersetzen Implementierungen in Tests, fügen neues Verhalten hinzu, ohne den Kern zu ändern (OCP). Wir betrachten, wie Schnittstellen den Mustern Observer, Strategy, Command zugrunde liegen, und zeigen Praxisbeispiele (UserRepository, NotificationSender, Zahlungsstrategien).

In dieser Vorlesung behandeln wir Lambda-Ausdrücke in Java: was sie sind und wozu sie dienen, wie Syntax und Kurzformen aufgebaut sind, wie Lambdas mit funktionalen Interfaces ( @FunctionalInterface) zusammenhängen, worin sie sich von anonymen Klassen unterscheiden und wie das Variablen-Capturing funktioniert ( final / effectively final). An praktischen Beispielen mit Runnable, Consumer, Comparator, Function und der Stream-API sehen wir, wie man kürzer und verständlicher schreibt. Wir schließen mit dem Abschnitt „Typische Fehler“ und Tipps, wie man sie vermeidet.

Kurzanleitung zu Methodenreferenzen in Java: wo und wie man eine Methodenreferenz anstelle von Lambdas verwendet. Wir betrachten 4 Formen: Class::method (statisch und „auf einer Instanz“), object::method, Class::new. Wir verstehen die Zuordnung von Signaturen zu funktionalen Interfaces, vergleichen mit Lambda-Ausdrücken, schauen uns praktische Beispiele mit forEach, sort, map an und besprechen typische Fehler (abweichende Signaturen, Methodenüberladung usw.).

In dieser Vorlesung erklären wir, warum in Java 8 default-Methoden in Schnittstellen eingeführt wurden, wie sie es ermöglichen, APIs weiterzuentwickeln, ohne alten Code zu brechen, ihre Syntax (Schlüsselwort default vor dem Rückgabetyp) und das Verhalten in Implementierungen. Anhand von Beispielen aus der Standardbibliothek ( List: forEach, replaceAll, sort) betrachten wir die praktische Anwendung. Wir besprechen Einschränkungen: Methoden von Object ( equals/ hashCode/ toString) dürfen nicht überschrieben werden, außerdem die Regeln zur Konfliktauflösung bei Mehrfachimplementierung und typische Fehler.

Wir beleuchten, wie und warum Schnittstellen in Java statische Methoden erhalten haben: Deklarationssyntax, Unterschied zu default-Methoden, zentrale Einschränkungen (werden nicht vererbt, werden nicht überschrieben, Aufruf nur über den Schnittstellennamen, Zugriff nur auf static-Member, Unterstützung von private static ab Java 9+). In der Praxis schauen wir uns Movable.resetPosition(), einen Hilfs- Logger, die Collection-Fabriken List.of()/ Set.of()/ Map.of() und das Utility Comparator.reverseOrder() an. Am Ende – typische Fehler und wie man sie vermeidet.