Lektionen

Wir klären, was die Datei module-info.java ist, wo sie sich im Projekt befindet und wie ein Modul mit dem Schlüsselwort module deklariert wird. Wir lernen, wie man das API mit exports exportiert, Abhängigkeiten mit requires einbindet, und schauen uns zusätzliche Direktiven an ( opens, uses, provides ... with). In der Vorlesung gibt es Beispiele, Regeln zur Benennung von Modulen, eine praktische Durchsicht der Projektstruktur und typische Fehler beim modularen Build.

Wie Java 9+ eine modulare Kapselung oberhalb von Klassen und Paketen eingeführt hat: Selbst public-Klassen sind verborgen, solange das Paket nicht ausdrücklich über exports in module-info.java geöffnet wird. Wir betrachten, wie man Abhängigkeiten mit requires deklariert, wie man die Sichtbarkeit mit exports to einschränkt, wie sich die Ebene module von private/ public unterscheidet und welche Kompilierfehler (zum Beispiel „package ... is not visible“, „cannot access ...“) darauf hinweisen, dass Sie exports oder requires vergessen haben.

Praxisleitfaden zur modularen Architektur in Java: wann und warum man Code in Module aufteilt; typische Schemata (Zwiebelarchitektur, Trennung in api/ impl, Testmodule); Konfiguration von Abhängigkeiten über module-info.java und die Schlüsselwörter requires/ exports; lauffähige Beispiele eines Projekts mit 3 Modulen; Integration mit Maven/ Gradle und IntelliJ IDEA sowie die Analyse typischer Fehler (zyklische Abhängigkeiten, nicht exportierte Pakete, falscher --module-path).

Wie man ein modulares Projekt in Java baut: der Unterschied zwischen classpath und module-path, wann der Schalter --module-path zu verwenden ist, wie man eine Mehrmodulstruktur in Maven und Gradle konfiguriert und wie man alles aus IntelliJ IDEA startet. Wir zeigen die Modulstruktur mit module-info.java, Abhängigkeiten über requires/ exports, die Konfiguration von Plugins und häufige Fehler beim Build.

Wir schauen uns an, wie man aus Java externe Befehle und Tools mit der Klasse ProcessBuilder startet: warum sie besser ist als Runtime. getRuntime(). exec(), wie man das Arbeitsverzeichnis über directory() und die Umgebungsvariablen über environment() konfiguriert sowie den Prozess über start(), waitFor() und die Streams getInputStream()/ getErrorStream()/ getOutputStream() steuert. Außerdem sprechen wir über Plattformunabhängigkeit ( cmd.exe/ ls), den Umgang mit stdout/ stderr und typische Fehler.

Praxis im Umgang mit externen Prozessen in Java: wie man stdout über Process.getInputStream() liest, Fehler aus stderr über Process.getErrorStream() abgreift, in stdin mit Process.getOutputStream() schreibt und außerdem die praktischen Methoden inputReader()/ errorReader()/ outputWriter() nutzt. Wir sehen uns Besonderheiten von Befehlen wie java -version an, das parallele Lesen der Streams zur Vermeidung eines Deadlock, den Umgang mit Zeichencodierungen ( "UTF-8") sowie eine kleine Bridge zu Python-Skripten.

Praxis der Steuerung externer Prozesse aus Java: auf das Ende mit waitFor() warten (inklusive Timeouts), Exit-Code auslesen, sauber über destroy()/ destroyForcibly() beenden, Hänger und „Zombie“-Prozesse verhindern – und dabei Ausgabestreams und Ausnahmen nicht vergessen. Wir besprechen plattformübergreifende Besonderheiten und typische Fehler.

In dieser Vorlesung klären wir, wie man aus Java einen „lebendigen“ Dialog mit externen Programmen aufbaut: in stdin schreiben, aus stdout und stderr lesen, gegenseitige Blockierungen ( deadlock) vermeiden, die Ausgabe parallel mit ExecutorService verarbeiten, Streams korrekt schließen und den Lebenszyklus von Process über den ProcessBuilder steuern. Wir sehen uns Beispiele mit einem interaktiven Skript in Python und dem Tool bc an und besprechen die Fallstricke der Pufferung sowie die Notwendigkeit von flush().

Ein praxisnaher Leitfaden für robuste Arbeit mit externen Prozessen in Java: wie man Hänger durch nicht gelesene Streams stdout/ stderr vermeidet, die Ausgabe-Kodierung korrekt konfiguriert (z. B. UTF-8, CP866), plattformübergreifende Unterschiede von Befehlen berücksichtigt ( ls vs dir), Berechtigungen und Exit-Codes über process.exitValue() behandelt, Ressourcen ohne Lecks schließt und interaktive gegenseitige Blockaden vermeidet. Wir betrachten den sachgemäßen Einsatz von ProcessBuilder, das parallele Lesen der Streams (Threads/ ExecutorService), das korrekte Beenden via process.destroy() sowie systemunabhängige Pfade mit File.separator.

Wir klären, was Reflexion in Java ist und warum Frameworks und Tools sie brauchen, wie das Objekt Class – das Herz der Reflexion – funktioniert und auf welche Arten man es erhält: über .class, getClass() und Class.forName(). Wir sprechen darüber, wann man Reflexion einsetzen sollte und wann man besser ohne sie auskommt, schauen uns Beispiele zum Abrufen von Metadaten an (Name, Paket, Superklasse, Schnittstellen), nehmen ein Mini‑Tool „Was für eine Klasse?“ auseinander und betrachten typische Fehler ( ClassNotFoundException, Leistung, Sicherheit).

In der Vorlesung behandeln wir Reflection in Java: wie man über das Class-API Informationen über Felder ( getFields()/ getDeclaredFields()), Methoden ( getMethods()/ getDeclaredMethods()), Konstruktoren ( getConstructors()/ getDeclaredConstructors()) und Annotationen ( getAnnotations()) erhält. Wir lesen Modifizierer über Modifier aus ( public, private, protected, static, final), klären den Unterschied „public vs declared“, bauen ein kleines Klasseninspektor-Tool und schauen uns ein Schaubild an.

In der Vorlesung besprechen wir Risiken und Einschränkungen der Reflection: das Umgehen der Kapselung über setAccessible( true), Versuche, final-Felder zu verändern, und warum das wegen JVM-Optimierungen gefährlich ist; das Schicksal des SecurityManager und wie das Modulsystem (Java 9+) zu InaccessibleObjectException führt. Wir sprechen über Performance-Verlust und den Verlust von Typsicherheit, moderne Alternativen ( record, sealed, Pattern Matching, APT, DI) und Best Practices. Am Ende — ein praktisches Beispiel mit dem JVM-Parameter --add-opens.