Lektionen

In dieser Vorlesung betrachten wir, was Vererbung in Java ist, wie man damit Code-Duplizierung vermeidet, und wie man Hierarchien mit dem Schlüsselwort extends deklariert. Wir sehen uns an, was genau eine Unterklasse erbt, welche Einschränkungen es gibt (Einfachvererbung, private Mitglieder, Konstruktoren), besprechen ein praktisches Beispiel mit Tieren, Besonderheiten rund um Konstruktoren und typische Fehler.

In dieser Vorlesung behandeln wir das Überschreiben von Methoden in Java: wie und warum eine Unterklasse das Verhalten der Elternklasse ersetzt, welchen Nutzen die Annotation @Override bringt, wie Polymorphie bei Aufrufen über eine Referenz des Basistyps funktioniert, sowie die wichtigsten Regeln (Signatur, Zugriffsmodifikatoren, Ausnahmen, Kovarianz) und Einschränkungen ( static, final, private). Wir schließen mit Praxis in einem Mini‑Projekt „Zoo“ und der Besprechung typischer Fehler ab.

Wir beleuchten das Schlüsselwort super in Java: wie man Methoden und Konstruktoren der Basisklasse aufruft, wie man auf verdeckte Felder der Elternklasse zugreift, wann und warum man das Verhalten über super und super(...) erweitert, sowie die Einschränkungen (in statischen Methoden nicht verwendbar, kein Zugriff auf private) und typische Fehler. Viele praktische Beispiele mit den Hierarchien Animal/ Cat/ Dog und Vehicle/ Car.

Wir lernen, Klassenhierarchien in Java zu entwerfen und zu implementieren: wie man Allgemeines und Spezielles identifiziert, einen Vererbungsbaum aufbaut, wo die Beziehung is-a sinnvoll ist und wann man besser Komposition ( has-a) verwendet. Wir betrachten anschauliche Beispiele (Tiere, Geometrie, Transport, Benutzer), architektonische Feinheiten und typische Designfehler.

In dieser Vorlesung besprechen wir die Grenzen des Vererbungsmodells in Java: einfache Klassenvererbung, keine Vererbung von Konstruktoren und die Nichtzugänglichkeit von private-Mitgliedern. Wir betrachten fragile Hierarchien und den Effekt „brechender“ Vererbung, zeigen Alternativen – Komposition ( has-a), Delegation und Schnittstellen – sowie Kriterien dafür, „wann extends wirklich nötig ist“. Außerdem weisen wir auf den Aufruf des Eltern-Konstruktors via super(...) und typische Designfehler hin.

In dieser Vorlesung behandeln wir Polymorphie in Java: was sie ist, worin sich overloading und overriding unterscheiden, wie Late Binding funktioniert und warum ein Interface viele Implementierungen haben kann. An praktischen Beispielen sehen wir, wie Polymorphie Architekturen vereinfacht, Code erweiterbar macht und die Kopplung zwischen Modulen reduziert.

Wir tauchen in die Methodenüberladung in Java ein: wann es sinnvoll ist, mehrere Versionen derselben Methode zu deklarieren, wie der Compiler die beste Übereinstimmung anhand der Parameter auswählt, warum man nicht nur nach dem Rückgabetyp überladen kann und wie überladene Konstruktoren sowie ... varargs funktionieren. Wir schauen uns Beispiele mit println an, bauen einen kleinen Calculator und gehen typische Fehler durch, die mit Autoboxing/automatischer Typumwandlung und Mehrdeutigkeit zwischen Integer/ Long zusammenhängen.

Wir beleuchten die Methodenüberschreibung in Java im Detail: wie Overriding Polymorphismus zur Laufzeit ermöglicht, worin es sich von overloading unterscheidet, welche Regeln gelten (Signaturen, Zugriff, Ausnahmen, Kovarianz), wie man @Override verwendet und die Logik der Oberklasse über super aufruft. Wir zeigen praktische Beispiele und gehen typische Fehler durch.

Wir zeigen Polymorphie an lebendigen Beispielen: wie man heterogene Objekte in einer einzigen Sammlung des Basistyps speichert und die „richtigen“ Methoden ohne if/ switch aufruft, warum das Hinzufügen einer neuen Unterklasse keine Umschreibung der Logik erfordert und welche Einschränkungen der Ansatz hat. Wir bauen eine Hierarchie von Mitarbeitenden mit der Methode work(), sprechen über Erweiterbarkeit und analysieren typische Fehler.

Wie abstrakte Klassen und Methoden einen gemeinsamen Vertrag definieren und Polymorphismus in Java ermöglichen: warum man kein abstraktes Objekt erzeugen kann, wie Unterklassen Pflichtmethoden implementieren, wie man über den Basistyp arbeitet und dabei das „richtige“ Verhalten erhält. Wir betrachten Beispiele mit Tieren und einer Mitarbeiterhierarchie, Syntaxnuancen und typische Fehler.

Ein verständlicher Einstieg in die Abstraktion in der objektorientierten Programmierung mit Java: was sie ist, wozu sie dient und wie man sie im Design anwendet. Wir besprechen Sprachmittel – abstrakte Klassen abstract class und Interfaces interface, abstrakte Methoden und die Arbeit über einen gemeinsamen Vertrag (z. B. Aufrufe wie payment.process() oder draw()). Anhand praktischer Beispiele ( Shape, Payment, Transport) zeigen wir, wie man Implementierungsdetails verbirgt, die Kopplung verringert und die Erweiterbarkeit des Systems vereinfacht.

In dieser Lektion zerlegen wir Schritt für Schritt abstrakte Klassen und Methoden in Java: wann man abstract braucht, wie man eine abstrakte class deklariert, worin der Unterschied zu interface besteht und wie man die verpflichtenden Methoden (zum Beispiel makeSound()) in Unterklassen implementiert. Wir untermauern die Theorie mit anschaulichen Beispielen ( Animal, Transport, Shape) und besprechen typische Fehler – vom Versuch, eine Instanz einer abstrakten Klasse zu erzeugen, bis hin zur falschen Verwendung von Modifikatoren.