Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: dpunkt.verlag
- Kategorie: Wissenschaft und neue Technologien
- Serie: Programmieren mit dpunkt
- Sprache: Deutsch
- Veröffentlichungsjahr: 2022
Bleiben Sie bei Java auf dem Laufenden!
- •Aktuelle Infos bis zur neuesten Java-Version
- •Vertiefen Sie Ihr Know-how durch praktische Übungen
- •Lernen Sie die wichtigen Änderungen kompakt kennen
Dieses Buch von Michael Inden richtet sich an alle Entwickler:innen mit soliden Programmierkenntnissen, die ihr Java-Wissen auf den neuesten Stand bringen und es durch eine Vielzahl an Übungen festigen möchten. Es beschreibt alle wichtigen Neuerungen ausgehend vom letzten Java 11 LTS bis hin zum aktuellen Java 17 LTS. Darüber hinaus bietet es einen Ausblick auf die Folgeversionen Java 18.
"Java – die Neuerungen in Java 17 LTS und 18" behandelt alle wesentlichen Änderungen. Einen Schwerpunkt bildet die Beschreibung einer Vielzahl an Syntaxverbesserungen und die Erweiterungen in diversen APIs. Beispiele sind eine viel prägnantere Syntax bei switch sowie die mehrzeiligen Strings und records, welche die Definition von Werteklassen erleichtern. Auch das immer populärer werdende Pattern Matching für instanceof und switch wird vorgestellt. Nicht nur in der Syntax sondern auch in den APIs finden sich herausragende Neuerungen, etwa der mit Java 11 offiziell ins JDK aufgenommene HTTP/2-Support sowie diverse Detailverbesserungen beispielsweise im Stream-API. Schließlich bietet die JVM mit Direct Compilation, der JShell, JMH sowie jpackage wichtige Neuerungen. Dabei ragen das JMH Framework zum Erstellen von Microbenchmarks sowie jpackage zum Bereitstellen von Self-Contained-Installationen heraus.
Auch fortgeschrittenere Themen, beispielsweise der Ersatz aus dem JDK entfallener Funktionalitäten wie JAXB oder auch das Zusammenspiel von Java 17 mit u.a. Spring, Jackson, JPA sowie SonarQube, runden dieses Buch ab.
Ein Anhang beschreibt einige Highlights aus den Java-Versionen 8, 9 und 10, um Ihnen damit den Umstieg auf modernes Java 17 und 18 zu erleichtern.
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 358
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Dipl.-Inform. Michael Inden ist Oracle-zertifizierter Java-Entwickler. Nach seinem Studium in Oldenburg hat er bei diversen internationalen Firmen in verschiedenen Rollen etwa als Softwareentwickler, -architekt, Consultant, Teamleiter, CTO sowie Leiter Academy gearbeitet. Nach rund 1,5 Jahren als freiberuflicher Autor und Trainer ist er seit Januar 2022 als Head of Development in Zürich tätig.
Michael Inden hat über zwanzig Jahre Berufserfahrung beim Entwurf komplexer Softwaresysteme gesammelt und an diversen Fortbildungen sowie mehreren Java-One-Konferenzen teilgenommen. Sein besonderes Interesse gilt dem Design qualitativ hochwertiger Applikationen sowie dem Coaching. Sein Wissen gibt er gerne als Trainer in internen und externen Schulungen und auf Konferenzen weiter, etwa bei der JAX/W-JAX, JAX London, Oracle Code One, ch.open sowie bei der Java User Group Switzerland.
Copyright und Urheberrechte:
Die durch die dpunkt.verlag GmbH vertriebenen digitalen Inhalte sind urheberrechtlich geschützt. Der Nutzer verpflichtet sich, die Urheberrechte anzuerkennen und einzuhalten. Es werden keine Urheber-, Nutzungs- und sonstigen Schutzrechte an den Inhalten auf den Nutzer übertragen. Der Nutzer ist nur berechtigt, den abgerufenen Inhalt zu eigenen Zwecken zu nutzen. Er ist nicht berechtigt, den Inhalt im Internet, in Intranets, in Extranets oder sonst wie Dritten zur Verwertung zur Verfügung zu stellen. Eine öffentliche Wiedergabe oder sonstige Weiterveröffentlichung und eine gewerbliche Vervielfältigung der Inhalte wird ausdrücklich ausgeschlossen. Der Nutzer darf Urheberrechtsvermerke, Markenzeichen und andere Rechtsvorbehalte im abgerufenen Inhalt nicht entfernen.
Michael Inden
Java – die Neuerungen in Version 17 LTS, 18 und 19
Michael Inden
Lektorat: Dr. Michael Barabas
Projektkoordinierung: Anja Weimer
Copy-Editing: Ursula Zimpfer, Herrenberg
Satz: Michael Inden
Herstellung: Stefanie Weidner, Frank Heidt
Umschlaggestaltung: Helmut Kraus, www.exclam.de
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
ISBN:
978-3-86490-902-3
978-3-96910-836-9
ePub
978-3-96910-837-6
mobi
978-3-96910-838-3
1. Auflage 2022
Copyright © 2022 dpunkt.verlag GmbH
Wieblinger Weg 17
69123 Heidelberg
Hinweis:
Dieses Buch wurde auf PEFC-zertifiziertem Papier aus nachhaltiger Waldwirtschaft gedruckt. Der Umwelt zuliebe verzichten wir zusätzlich auf die Einschweißfolie.
Schreiben Sie uns:
Falls Sie Anregungen, Wünsche und Kommentare haben, lassen Sie es uns wissen: [email protected].
Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.
Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.
Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buches stehen.
5 4 3 2 1 0
In Erinnerung an meine geliebte Mutter Marianne Inden»Wenn die Sonne untergeht, geht sie an anderer Stelle wieder auf.«
Inhaltsverzeichnis
1Einleitung
1.1Releasepolitik
1.2Inhaltsübersicht: Was erwartet Sie im Folgenden?
1.3Grundgerüst des Eclipse-Projekts
1.4Anmerkung zum Programmierstil
1.4.1Gedanken zur Sourcecode-Kompaktheit
1.4.2Gedanken zu final und var
1.4.3Blockkommentare in Listings
1.4.4Gedanken zur Formatierung
1.5Konfigurationen für Build-Tools und IDEs
1.5.1Java 17 mit Gradle
1.5.2Java 17 mit Maven
1.5.3Java 17 mit Eclipse
1.5.4Java 17 mit IntelliJ
1.6Ausprobieren der Beispiele und Lösungen
1.6.1Ausprobieren neuer Java-Features mit der JShell oder der Kommandozeile
1.6.2Ausprobieren neuer Java-Features in einer Sandbox
INeuerungen in Java 11 bis 17
2Neuerungen in Java 17 im Überblick
2.1JEPs im Überblick
2.1.1JEP 306: Restore Always-Strict Floating-Point Semantics
2.1.2JEP 356: Enhanced Pseudo-Random Number Generators
2.1.3JEP 382: New macOS Rendering Pipeline
2.1.4JEP 391: macOS/AArch64 Port
2.1.5JEP 398: Deprecate the Applet API for Removal
2.1.6JEP 403: Strongly Encapsulate JDK Internals
2.1.7JEP 406: Pattern Matching for switch (Preview)
2.1.8JEP 407: Remove RMI Activation
2.1.9JEP 409: Sealed Classes
2.1.10JEP 410: Remove the Experimental AOT and JIT Compiler
2.1.11JEP 411: Deprecate the Security Manager for Removal
2.1.12JEP 412: Foreign Function & Memory API (Incubator)
2.1.13JEP 414: Vector API (Second Incubator)
2.1.14JEP 415: Context-Specific Deserialization Filters
2.2Neue Releasepolitik im Überblick
3Syntaxneuerungen bis Java 17
3.1Text Blocks
3.1.1Grundlegende Syntax
3.1.2Besonderheiten
3.1.3Platzhalter
3.2Switch Expressions
3.2.1Einführendes Beispiel
3.2.2Vollständigkeitsprüfung
3.2.3Fallstricke der alten Syntax und Abhilfen
3.2.4Rückgabe mit yield
3.2.5Rückwärtskompatible Angabe bei case mit yield
3.3Records
3.3.1Einführendes Beispiel
3.3.2Records für DTOs und Rückgabewerte
3.3.3Erweiterungsmöglichkeiten
3.3.4Besonderheit – Generics in Records
3.3.5Besonderheit – Records und Interfaces
3.3.6Zusammenfassung
3.4Pattern Matching bei instanceof
3.4.1Neue Syntax und einführendes Beispiel
3.4.2Im Praxiseinsatz
3.5Sealed Types
3.5.1Neue Schlüsselwörter
3.5.2Einführendes Beispiel
3.5.3Wissenswertes
3.6Lokale Enums und Interfaces
3.7Statische Attribute und Methoden in inneren Klassen
3.8Pattern Matching und Erweiterung für switch (Preview)
3.8.1Einfaches Pattern Matching
3.8.2Pattern Matching mit Bedingung
3.8.3Spezialfall: Behandlung von null
4Übungen zu den Syntaxneuerungen in JDK 11 bis 17
4.1Aufgaben
4.2Lösungen
5Neues und Änderungen in den Java-17-APIs
5.1Erweiterungen in der Klasse String
5.1.1Die Methode isBlank()
5.1.2Die Methode lines()
5.1.3Die Methode repeat(int)
5.1.4Die Methoden strip(), stripLeading() und stripTrailing()
5.1.5Die Methode indent()
5.1.6Die Methode transform()
5.1.7Die Methode formatted()
5.2Erweiterung im Interface Predicate<T>
5.3Erweiterung in der Klasse Optional<T>
5.4Erweiterungen in der Utility-Klasse Files
5.4.1Die Methoden writeString() und readString()
5.4.2Die Methode mismatch()
5.5Erweiterungen im Stream-API
5.5.1Der teeing()-Kollektor
5.5.2Die Methode toList() als Shortcut zum Kollektor
5.5.3Die Intermediate Operation mapMulti()
5.6HTTP/2-API
5.6.1Einführung
5.6.2Real-World-Example: Wechselkurs mit REST
5.7Die Utility-Klasse CompactNumberFormat
5.7.1Einführendes Beispiel
5.7.2Rundung steuern
5.7.3Eigene Einheiten angeben
5.8Verschiedenes und Deprecations
5.8.1Unix-Domain-Socket Channels
5.8.2Day Period Support
5.8.3Aufruf von Defaultmethoden aus Dynamic Proxies
5.8.4Deprecations der Konstruktoren der Wrapper-Klassen
6Übungen zu den API-Neuerungen in JDK 11 bis 17
6.1Aufgaben
6.2Lösungen
7Änderungen in der JVM bis Java 17
7.1Verbesserung bei NullPointerExceptions
7.1.1Einführende Beispiele
7.1.2Fehlersuche bei komplexen Ausdrücken
7.2Java + REPL => jshell
7.2.1Einführendes Beispiel
7.2.2Weitere Kommandos und Möglichkeiten
7.2.3Neuere Java-Features nutzen
7.2.4Komplexere Aktionen
7.2.5JShell-API
7.3Launch Single-File Source-Code Programs (JDK 11)
7.3.1Einführendes Beispiel
7.3.2Palindrom-Prüfung
7.3.3REST-Calls mit HTTP/2
7.3.4Besonderheit: Shebang-Skript
7.3.5Besonderheit: Preview-Features ausprobieren
7.4Microbenchmarks und JMH
7.4.1Eigene Microbenchmarks und Varianten davon
7.4.2Microbenchmarks mit JMH
7.4.3Weitere Microbenchmarks mit JMH
7.4.4Fallstricke beim Benchmarking mit JMH
7.4.5Projekt zum Experimentieren
7.4.6Fazit zu JMH
7.5Das Packaging-Tool jpackage
7.5.1Einführung
7.5.2jpackage am Beispiel
7.5.3Externe Bibliotheken mit jpackage einbinden
7.5.4Hintergrundwissen: Verzeichnisstruktur und -inhalt der Distributionen
7.6Veränderungen bei den Garbage Collectors
7.6.1Epsilon Garbage Collector (JDK 11)
7.6.2Der Garbage Collector namens ZGC (JDK 15)
7.6.3Entfernung von Concurrent Mark Sweep (CMS)
7.7Ausgliederungen/Deprecations
7.7.1Entfernung der JavaScript-Engine
7.7.2Das Tool jdeprscan
7.7.3Ausgliederung von JavaFX
7.7.4Ausgliederung von Java EE und CORBA
7.7.5Beispiel JAXB
8Übungen zu den JVM-Neuerungen in JDK 11 bis 17
8.1Aufgaben
8.2Lösungen
IIAusblick
9Neuerungen in Java 18
9.1Java-18-JEPs im Überblick
9.1.1JEP 400: UTF-8 by Default
9.1.2JEP 408: Simple Web Server
9.1.3JEP 413: Code Snippets in Java API Documentation
9.1.4JEP 416: Reimplement Core Reflection with Method Handles
9.1.5JEP 417: Vector API (Third Incubator)
9.1.6JEP 418: Internet-Address Resolution SPI
9.1.7JEP 419: Foreign Function & Memory API (Second Incubator)
9.1.8JEP 420: Pattern Matching for switch (Second Preview)
9.1.9JEP 421: Deprecate Finalization for Removal
9.2API-Neuerungen
9.2.1Neuerungen in der Klasse FileInputStream
9.2.2Neuerungen in der Klasse Math
9.2.3Neuerungen in der Klasse Duration
9.2.4Neuerungen in der Aufzählung SourceVersion
9.2.5Deprecations
9.3Notwendige Anpassungen für Build-Tools und IDEs
9.3.1Java 18 mit Gradle
9.3.2Java 18 mit Maven
9.3.3Java 18 mit Eclipse
9.3.4Java 18 mit IntelliJ
9.4Fazit
10Ausblick auf Java 19
10.1Java-19-JEPs im Überblick
10.1.1JEP 405: Record Patterns (Preview)
10.1.2JEP 422: Linux/RISC-V Port
10.1.3JEP 424: Foreign Function & Memory API (Preview)
10.1.4JEP 425: Virtual Threads (Preview)
10.1.5JEP 426: Vector API (Fourth Incubator)
10.1.6JEP 427: Pattern Matching for switch (Third Preview)
10.1.7JEP 428: Structured Concurrency (Incubator)
10.2Installation der Java-19-Early-Access-Builds
10.2.1Allgemeine Aktionen
10.2.2Weitere Aktionen unter macOS
10.2.3Weitere Aktionen unter Windows
10.2.4Java-19-Installation prüfen
11Zusammenfassung und Schlusswort
11.1Gedanken zum Umstieg
11.2Fazit
11.3Abschließende Hinweise
IIIAnhang
AWesentliches aus Java 8, 9 und 10
A.1Einstieg in Lambdas
A.1.1Lambdas am Beispiel
A.1.2Functional Interfaces und SAM-Typen
A.1.3Type Inference und Kurzformen der Syntax
A.1.4Methodenreferenzen
A.1.5Das Interface Predicate<T>
A.2Streams im Überblick
A.2.1Streams erzeugen – Create Operations
A.2.2Intermediate und Terminal Operations im Überblick
A.2.3Intermediate Operations
A.2.4Terminal Operations
A.3Neuerungen in der Datumsverarbeitung
A.3.1Die Klassen LocalDate, LocalTime und LocalDateTime
A.3.2Die Klasse Duration
A.3.3Die Klasse Period
A.3.4Datumsarithmetik mit TemporalAdjusters
A.4Diverse Erweiterungen
A.4.1Erweiterungen im Interface Comparator<T>
A.4.2Die Klasse Optional<T>
A.4.3Collection-Factory-Methoden
A.4.4Erweiterungen im NIO und der Klasse Files
A.4.5Die Klasse CompletableFuture<T>
A.5Weitere Syntaxneuerungen
A.5.1Anonyme innere Klassen und der Diamond Operator
A.5.2Syntaxerweiterung var
BDie Build-Tools Gradle und Maven im Überblick
B.1Projektstruktur für Gradle und Maven
B.2Einführung in Gradle
B.3Einführung Maven
B.3.1Maven im Überblick
B.3.2Maven am Beispiel
Literaturverzeichnis
Index
Vorwort
Zunächst einmal bedanke ich mich bei Ihnen, dass Sie sich für dieses Buch entschieden haben. Hierin finden Sie eine Vielzahl an Informationen zu den Neuerungen in der aktuellen Java-Version 17 LTS (Long Term Support) sowie wesentliche Neuerungen aus den Vorgängern 11 LTS bis 16. Natürlich darf auch ein Blick auf das brandaktuelle Java 18 inklusive eines Ausblicks auf die Neuerungen im zukünftigen Java 19 nicht fehlen.
Zielgruppe
Dies ist kein Buch für Programmierneulinge, sondern richtet sich an diejenigen Leser, die bereits solides Java-Know-how besitzen und sich kurz und prägnant über die wichtigsten Neuerungen in den Java-Versionen 11 bis 17 sowie 18 und 19 informieren wollen. Dieses Buch wendet sich im Speziellen an zwei Zielgruppen:
Zum einen sind dies
engagierte Hobbyprogrammierer und Informatikstudenten
, aber auch
Berufseinsteiger
, die Java als Sprache beherrschen und an den Neuerungen in den aktuellen Java-Versionen interessiert sind.
Zum anderen ist das Buch für
erfahrene Softwareentwickler und -architekten
gedacht, die ihr Wissen ergänzen oder auffrischen wollen, um für zukünftige Projekte abschätzen zu können, ob und – wenn ja – für welche Anforderungen die neuen Java-Versionen eine gewinnbringende Alternative darstellen können.
Was vermittelt dieses Buch?
Sie als Leser erhalten in diesem Buch neben Theoriewissen eine Vertiefung durch praktische Beispiele, sodass der Umstieg auf Java 17 LTS, das aktuelle Java 18 oder gar das zukünftige Java 19 in eigenen Projekten erfolgreich gemeistert werden kann. Erleichtert wird ein Umstieg durch eine Vielzahl an Übungen zu den wichtigsten Features, insbesondere denjenigen aus Java 17 LTS.
Um die Beispiele des Buchs möglichst präzise und elegant zu halten, verwende ich diverse Features aus Java 8, 9 und 10. Deshalb ist es hilfreich, wenn Sie sich damit schon beschäftigt haben. Alle, die eine kleine Auffrischung benötigen, finden zum leichteren Einstieg in Anhang A einen Crashkurs zu den wesentlichen Neuerungen in den Java-Versionen 8 bis 10.
Aufbau dieses Buchs
Nachfolgend möchte ich die Themen der einzelnen Kapitel kurz vorstellen.
Kapitel 1 – Einleitung Die Einleitung stimmt Sie auf Java 11 bis 19 ein und gibt dazu einen Überblick, was Sie so alles in diesem Buch bzw. als Neuerungen erwartet. Zudem thematisiere ich den Programmierstil und gebe Hinweise, welche Voraussetzungen nötig sind, um die aktuellen Java-Versionen mit Build-Tools und IDEs zu verwenden.
Kapitel 2 – Neuerungen in Java 17 im Überblick Dieses Kapitel listet die Erweiterungen aus Java 17 auf und stellt diese in jeweils eigenen Abschnitten kurz vor. Dadurch haben Sie bereits eine gute Orientierung, in welchem der Folgekapitel Sie dann die Lektüre fortsetzen möchten. Bei generellem Interesse lesen Sie einfach stringent von vorne nach hinten.
Kapitel 3 – Syntaxneuerungen bis Java 17 Zunächst widmen wir uns verschiedenen Änderungen an der Syntax von Java. Das Spektrum reicht von mehrzeiligen Strings und sogenanntem Pattern Matching bei instanceof bis zu größeren Erweiterungen bei switch sowie den Records als eine extrem kompakte Schreibweise zum Deklarieren spezieller Datencontainerklassen. Darüber hinaus gibt es einige für die Praxis oft weniger relevante Dinge, die kurz vorgestellt werden.
Kapitel 4 – Übungen zu den Syntaxneuerungen in JDK 11 bis 17 Dieses Kapitel bietet einen umfangreichen Satz an Übungsaufgaben, um Sie mit den Neuerungen und Änderungen in der Syntax vertraut zu machen. Für sämtliche Aufgaben werden am Kapitelende korrespondierende Musterlösungen präsentiert.
Kapitel 5 – Neues und Änderungen in den Java-17-APIs In den APIs des JDKs finden sich diverse Neuerungen. Dieses Potpourri umfasst Ergänzungen in der Klasse String, kleinere Erweiterungen im Interface Predicate<T> sowie der Klasse Optional<T> und Convenience-Funktionalitäten in der Utility-Klasse Files. Auch das Stream-API bietet Neuerungen unter anderem den sogenannten Teeing-Kollektor sowie die Methode mapMulti(). Als Highlight wird das HTTP/2-API thematisiert.
Kapitel 6 – Übungen zu den API-Erweiterungen in JDK 11 bis 17 Dieses Kapitel bietet einen umfangreichen Satz an Übungsaufgaben bezüglich der Neuerungen und Änderungen in den APIs. Für sämtliche Aufgaben werden am Kapitelende korrespondierende Musterlösungen präsentiert.
Kapitel 7 – Änderungen in der JVM bis Java 17 In diesem Kapitel beschäftigen wir uns mit Änderungen in der JVM, etwa bei der Garbage Collection oder der Einführung der jshell. Java 11 bringt mit dem Feature »Launch Single-File Source-Code Programs« die Möglichkeit, Java-Klassen ohne explizite vorherige Kompilierung ausführen zu können. Unter anderem sind einige Module zu CORBA, JavaFX usw. nun nicht mehr Bestandteil des JDKs. Darüber hinaus könnte Sie das Microbenchmark-Framework JMH interessieren. Schließlich behandle ich das Tool jpackage zum Erzeugen installierbarer Distributionen.
Kapitel 8 – Übungen zu den JVM-Neuerungen in JDK 11 bis 17 Für einige der Neuerungen in der JVM bietet dieses Kapitel ein paar Übungsaufgaben inklusive einer kurzen Darstellung möglicher Lösungen.
Kapitel 9 – Neuerungen in Java 18 Dieses Kapitel bietet einen fundierten Überblick und Einstieg in die Neuerungen aus Java 18, die in jeweils eigenen Abschnitten kurz vorgestellt werden. Dabei werden zunächst die auf JEP (JDK Enhancement Proposal) basierenden Erweiterungen besprochen. Ergänzend werfen wir einen Blick auf einige Veränderungen in den APIs und schließlich schauen wir uns an, wie wir Java 18 mit Build-Tools und IDEs verarbeiten können.
Kapitel 10 – Ausblick auf Java 19 In diesem Kapitel thematisiere ich die Neuerungen aus Java 19, dessen offizielles Release für den September 2022 angekündigt ist. Derzeit, im Juni 2022, ist der Inhalt (nahezu) final und jeder JEP wird kurz beschrieben und in einigen Fällen mit konkreten Beispielen veranschaulicht. Zudem gehe ich darauf ein, wie Sie das Preview-Release installieren und auf Ihrem Rechner für erste Experimente aktivieren können.
Kapitel 11 – Zusammenfassung und Schlusswort Dieses Kapitel beginnt mit einigen Gedanken zum Umstieg auf die neuesten Java-Versionen und fasst danach die Themen rund um die vielfältigen Neuerungen bis zum aktuellen Java 18 sowie dem zukünftigen Java 19 noch einmal kurz zusammen.
Anhang A – Wesentliches aus Java 8, 9 und 10 In Anhang A werden für dieses Buch wesentliche Ergänzungen aus den Java-Versionen 8 bis 10 rekapituliert. Das erleichtert Ihnen das Verständnis der Neuerungen in aktuellen Java-Versionen, selbst dann, wenn Sie sich noch nicht eingehend mit Java 8, 9 oder 10 beschäftigt haben. Neben einer Vorstellung der funktionalen Programmierung mit Lambdas widmen wir uns den Streams, einer wesentlichen Neuerung in JDK 8 zur Verarbeitung von Daten. Abgerundet wird Anhang A durch einen kurzen Blick auf das Date and Time API und verschiedene andere Erweiterungen.
Anhang B – Die Build-Tools Gradle und Maven im ÜberblickAnhang B liefert eine kurze Einführung in die Build-Tools Gradle und Maven. Ersteres wird auch für die Beispiele dieses Buchs zur Übersetzung genutzt. Mithilfe des vermittelten Wissens sollten Sie dann auch kleinere eigene Projekte mit einem Build-System ausstatten können. Darüber hinaus wird in diesem Anhang das Build-Tool Maven überblicksartig vorgestellt. Es war jahrelang der De-facto-Standard und deswegen lassen sich Maven-Projekte einfacher als andere in die gängigen IDEs importieren.
Sourcecode und ausführbare Programme
Um den Rahmen des Buchs nicht zu sprengen, stellen die Listings häufig nur Ausschnitte aus lauffähigen Programmen dar, wobei wichtige Passagen zum besseren Verständnis mitunter fett hervorgehoben sind. Der vollständige Sourcecode steht auf der Webseite https://dpunkt.de/produkt/java-die-neuerungen-in-version-17-lts-18-und-19/ zum Download bereit. Neben dem Sourcecode befinden sich auf der Webseite auch mehrere Eclipse-Projekte, über die sich alle Programme ausführen lassen.
Ergänzend wird dort jeweils die Datei build.gradle mitgeliefert, die den Ablauf des Builds für Gradle beschreibt. Dieses Build-Tool besitzt viele Vorzüge, wie die kompakte und gut lesbare Notation, und vereinfacht die Verwaltung von Abhängigkeiten enorm. Darüber hinaus erlaubt Gradle das Starten von Programmen, wobei der jeweilige Programmname in Kapitälchenschrift, etwa DATETIMEEXAMPLE, angegeben wird.
Blockkommentare in Listings
Beachten Sie bitte, dass sich in den Listings diverse Blockkommentare finden, die der Orientierung und dem besseren Verständnis dienen. In der Praxis sollte man derartige Kommentierungen mit Bedacht einsetzen und lieber einzelne Sourcecode-Abschnitte in Methoden auslagern. Für die Beispiele des Buchs dienen diese Kommentare aber als Anhaltspunkte, weil die eingeführten oder dargestellten Sachverhalte für Sie als Leser vermutlich noch neu und ungewohnt sind.
Konventionen
Verwendete Zeichensätze
In diesem Buch gelten folgende Konventionen bezüglich der Schriftart: Neben der vorliegenden Schriftart werden wichtige Textpassagen kursiv oder kursiv und fett markiert. Englische Fachbegriffe werden eingedeutscht großgeschrieben, etwa Event Handling. Zusammensetzungen aus englischen und deutschen (oder eingedeutschten) Begriffen werden mit Bindestrich verbunden, z. B. Plugin-Manager. Namen von Programmen und Entwurfsmustern werden in KAPITÄLCHEN geschrieben. Listings mit Sourcecode sind in der Schrift Courier gesetzt, um zu verdeutlichen, dass dies einen Ausschnitt aus einem Java-Programm darstellt. Auch im normalen Text wird für Klassen, Methoden, Konstanten und Parameter diese Schriftart genutzt.
Tipps und Hinweise aus der Praxis
Dieses Buch ist mit diversen Praxistipps gespickt. In diesen werden interessante Hintergrundinformationen präsentiert oder es wird auf Fallstricke hingewiesen.
Tipp: Praxistipp
In derart formatierten Kästen finden sich im späteren Verlauf des Buchs immer wieder einige wissenswerte Tipps und ergänzende Hinweise zum eigentlichen Text.
Verwendete Klassen aus dem JDK
Werden Klassen des JDKs erstmalig im Text erwähnt, so wird deren voll qualifizierter Name, d. h. inklusive der Package-Struktur, angegeben: Die Klasse String würde demnach als java.lang.String notiert – alle weiteren Nennungen erfolgen dann ohne Angabe des Package-Namens. Diese Regelung erleichtert initial die Orientierung und ein Auffinden im JDK und zudem wird der nachfolgende Text nicht zu sehr aufgebläht. Die voll qualifizierte Angabe hilft insbesondere, da in den Listings eher selten import-Anweisungen abgebildet werden.
Im Text beschriebene Methodenaufrufe enthalten in der Regel die Typen der Übergabeparameter, etwa substring(int, int). Sind die Parameter in einem Kontext nicht entscheidend, wird mitunter auf deren Angabe aus Gründen der besseren Lesbarkeit verzichtet – das gilt ganz besonders für Methoden mit generischen Parametern.
Verwendete Abkürzungen
Im Buch verwende ich die in der nachfolgenden Tabelle aufgelisteten Abkürzungen. Weitere Abkürzungen werden im laufenden Text in Klammern nach ihrer ersten Definition aufgeführt und anschließend bei Bedarf genutzt.
Abkürzung
Bedeutung
API
Application Programming Interface
ASCII
American Standard Code for Information Interchange
(G)UI
(Graphical) User Interface
IDE
Integrated Development Environment
JDK
Java Development Kit
JEP
JDK Enhancement Proposal
JLS
Java Language Specification
JRE
Java Runtime Environment
JSR
Java Specification Request
JVM
Java Virtual Machine
Danksagung
Ein Fachbuch zu schreiben ist eine schöne, aber arbeitsreiche und langwierige Aufgabe. Alleine kann man dies kaum bewältigen. Daher möchte ich mich an dieser Stelle bei allen bedanken, die direkt oder indirekt zum Gelingen des Buchs beigetragen haben. Insbesondere konnte ich bei der Erstellung des Manuskripts auf ein starkes Team an Korrekturlesern zurückgreifen. Es ist hilfreich, von den unterschiedlichen Sichtweisen und Erfahrungen profitieren zu dürfen.
Zunächst einmal möchte ich mich bei Michael Kulla, der als Trainer für Java SE und Java EE bekannt ist, für sein mehrmaliges, gründliches Review vieler Kapitel und die fundierten Anmerkungen bedanken. Dank Ralph Willenborg enthält der Text doch diverse Tippfehler weniger und hat auch strukturell gewonnen. Sven Friederichs hat an verschiedenen Stellen sprachlich für mehr Stringenz gesorgt und darüber hinaus einige inhaltliche Verbesserungsvorschläge eingebracht. Schließlich gab mir Jonas Hübner noch den einen oder anderen Hinweis. Danke nochmals euch allen!
Ebenso geht ein Dankeschön an das Team des dpunkt.verlags (Dr. Michael Barabas, Anja Weimer und Stefanie Weidner) für die tolle Zusammenarbeit. Außerdem möchte ich mich bei Ursula Zimpfer für ihre Adleraugen beim Copy-Editing bedanken.
Anregungen und Kritik
Trotz großer Sorgfalt und mehrfachen Korrekturlesens lassen sich missverständliche Formulierungen oder sogar Fehler leider nicht vollständig ausschließen. Falls Ihnen etwas Derartiges auffallen sollte, so zögern Sie bitte nicht, mir dies mitzuteilen. Gerne nehme ich auch Anregungen oder Verbesserungsvorschläge entgegen. Kontaktieren Sie mich bitte per Mail unter:
Zürich, im Juni 2022
Michael Inden
1Einleitung
Dieses Buch stellt Ihnen alle wesentlichen Neuerungen aus den LTS-Releases (Long Term Support) Java 11 und 17 vor und behandelt damit natürlich auch die dazwischen liegenden Releases wie Java 12, 13, 14 usw. Darüber hinaus gebe ich einen Ausblick auf das brandaktuelle Java 18 und das zukünftige Java 19.
Alle Leser, die privat oder beruflich noch auf Java 8 setzen, finden in Anhang A einen kompakten Schnelleinstieg zu den herausragendsten bzw. bedeutendsten Änderungen der Java-Versionen 8, 9 sowie 10, um sich für die Erweiterungen ab Java 11 inhaltlich und syntaktisch vorzubereiten.
Bevor wir uns ein wenig mit den in diesem Buch behandelten Themen beschäftigen, möchte ich die Veränderungen der letzten Jahre in der Releasepolitik von Oracle darlegen, weil sich hier einiges getan hat.
1.1Releasepolitik
Vor Java 9 gab es keinen festen Takt oder Releasezyklus. Stattdessen wurde die Veröffentlichung einer neuen Java-Version an die Fertigstellung wesentlicher Features geknüpft. Wir alle kennen es noch gut: Früher wurden Java-Releases aufgrund unfertiger Features häufiger verschoben. Um dem entgegenzuwirken, hat Oracle nach dem Erscheinen von Java 9 auf einen halbjährlichen Releasezyklus umgestellt. Das erlaubt es, die jeweils bis zu diesem Zeitpunkt fertig implementierten Funktionalitäten zu veröffentlichen. Allerdings sind logischerweise nicht immer schon alle Features auch so weit, um final veröffentlicht zu werden. Daher gibt es seit Java 9 zwei Besonderheiten: die Preview-Features und die Incubator-Features.
Preview-Features
Sogenannte Preview-Features sind zwar vollständig spezifiziert und implementiert. Sie werden aber zunächst als Vorschau zum Sammeln von Erfahrungen und Feedback ins JDK integriert. Durch die Rückmeldungen möchte man der Funktionalität dann in Folgereleases einen weiteren Feinschliff geben. Allerdings sind Preview-Features standardmäßig nicht zugänglich und müssen explizit über die Angabe von --enable-preview sowohl beim Kompilieren als auch beim Ausführen über den gleichnamigen JVM-Aufrufparameter freigeschaltet bzw. aktiviert werden, um die Preview-Features in eigenen Programmen verwenden zu können.
Incubator-Features
Ergänzend zu den Preview-Features gibt es noch sogenannte Incubator-Features, die oftmals in Form korrespondierender Module implementiert und bereitgestellt werden. Auch hierbei geht es um das Sammeln von Erfahrungen und Feedback, allerdings auf einer vorläufigen Umsetzung. Es kann bei Incubator-Features durchaus sein, dass sich Dinge noch grundlegend ändern oder sogar später vollständig entfernt bzw. gar nicht in ein finales JDK aufgenommen werden. Weil Incubator-Features bzw. die bereitstellenden Module nicht offizieller Bestandteil des JDKs sind, müssen diese speziell aufgenommen werden. Dazu dient der JVM-Aufrufparameter --add-modules. Dieser ist interessanterweise nicht beim Kompilieren, sondern nur beim Ausführen anzugeben.
Releasekadenz im Wandel und die Auswirkungen
Kommen wir auf die Releasekadenz zurück. Bis einschließlich Java 9 wurden neue Java-Versionen immer Feature-basiert veröffentlicht. Das hatte in der Vergangenheit oftmals und mitunter auch beträchtliche Verschiebungen des geplanten Releasetermins zur Folge, nämlich immer dann, wenn für die Version wesentliche Features noch nicht fertiggestellt waren. Insbesondere deshalb verzögerten sich die Veröffentlichungen von Java 8 und Java 9 um mehrere Monate bzw. sogar über ein Jahr. Erinnern wir uns: Die Java-Gemeinde musste auf die Veröffentlichung von Java 9 deutlich länger als ursprünglich geplant warten – es gab gleich mehrere Verschiebungen, zunächst von September 2016 auf März 2017, dann auf Juli 2017 und schließlich auf September 2017. Schlimmer noch: Es war damals absolut nicht abzusehen oder vorab zu planen, wann eine neue Java-Version tatsächlich veröffentlicht werden würde.
Mit der Umstellung auf eine zeitbasierte Releasestrategie möchte man derartigen Verzögerungen entgegenwirken und die Planbarkeit erhöhen, indem jedes halbe Jahr eine neue Java-Version veröffentlicht wird, die all jene Features enthält, die bereits bis zu dem Termin fertig sind. Zudem sollte dann alle drei Jahre eine LTS-Version (Long Term Support) erscheinen. Eine solche ist in etwa vergleichbar mit den früheren Major-Versionen. Das war zwischen Java 11 und 17 dann auch der Fall. Mit Letzterem wurde dann eine Verkürzung des LTS-Zyklus auf 2 Jahre beschlossen, wodurch auch diejenigen Firmen schneller von den Neuerungen profitieren, die lediglich von LTS zu LTS springen wollen oder können.
Lassen Sie mich noch auf Folgendes hinweisen: Zwar kann die schnelle, halbjährliche Releasefolge eine größere Herausforderung für Toolhersteller sein, für uns als Entwickler ist es aber oftmals positiv, weil wir potenziell weniger lang auf neue Features warten müssen. Das konnte früher recht zermürbend sein.
Allerdings gilt das Positive vor allem für eigene Hobbyprojekte, weil man dort mit den Neuerungen experimentieren kann und weniger durch Restriktionen eingeschränkt ist. Im professionellen Einsatz wird man eher auf Kontinuität und die Verfügbarkeit von Security Updates setzen, weshalb in diesem Kontext vermutlich nur LTS-Versionen in Betracht kommen, um Migrationsaufwände kalkulierbar und besser planbar zu halten.
Tipp: Am Rande …
Für jeden Entwickler (Amateur oder Profi) hat der halbjährliche Releasezyklus einen weiteren Vorteil: Man kann sich häppchenweise mit neuen Features beschäftigen, wenn sie erscheinen, und muss nicht alle zwei, drei oder mehr Jahre einen Riesenbatzen Neuerungen am Stück durcharbeiten, wobei man durch den schieren Umfang an Änderungen gegebenenfalls einige relevante Dinge übersehen kann oder aus Zeitgründen auf »das les ich mir später durch« verschieben muss.
Lizenzpolitik im Wandel und die Auswirkungen
Nicht nur beim Releasezyklus, sondern insbesondere auch bei der Lizenzpolitik gab es in den letzten Jahren ein paar Überraschungen.
All diejenigen, die Java 11 herunterladen wollten, wurden durch einen markanten Hinweis auf die Änderungen in der Lizenzpolitik hingewiesen.
Abbildung 1-1Hinweis auf neue Lizenzbedingungen, exemplarisch für Java 11
Dort war zu entnehmen, dass sich die Bedingungen ändern, wenn Sie Ihre Software kommerziell vertreiben oder dies planen: Das bislang selbst in Produktionssystemen immer kostenfrei verwendbare Oracle JDK ist für Java 11 leider kostenpflichtig. Als Alternative existiert etwa das OpenJDK (https://openjdk.java.net/). Während der Entwicklung kann das Oracle JDK allerdings weiterhin kostenfrei genutzt werden.
Dieser Schritt, die Benutzer zur Lizenzierung zu nötigen, hat aber bei der Entwicklergemeinde für eine ziemliche Verstimmung gesorgt. Und es kam noch schlimmer: Kurze Zeit nach der Einschränkung für Java 11 wurde rückwirkend auch Java 8 kostenpflichtig. Viele Firmen haben daher erst einmal keine weiteren Updates auf neuere Versionen vorgenommen.
Es gab darüber hinaus eine massive Gegenreaktion. Dadurch, dass das OpenJDK seit Java 11 auf den gleichen Sourcen wie das Oracle JDK beruht und man das Open-JDK kostenfrei beziehen kann, haben sich diverse Firmen und Konsortien daran gemacht, freie Versionen von Java bereitzustellen. Hier seien Azul Systems, Adopt Open-JDK (nun Adoptium, an dem unter anderem IBM, Microsoft und Red Hat mitarbeiten) oder auch Amazon Corretto stellvertretend für viele weitere genannt.
Bei Oracle hatte man mit der Veröffentlichung von Java 17 ein Einsehen und das Oracle JDK steht nun auch für kommerzielle Zwecke wieder kostenfrei zur Verfügung. Die zugehörige Lizenz wird übrigens als No-Fee Terms and Conditions (NFTC) bezeichnet.
Ein wenig unverständlich ist allerdings, dass Java 11 weiterhin einer kostenpflichtigen Lizenz unterliegt. Damit wird es noch unattraktiver und wohl kaum mehr als Zwischenschritt auf dem Weg zu Java 17 eingesetzt werden – es sei denn, man nimmt ein anderes JDK als das von Oracle. Aber mittlerweile befinden wir uns schon auf dem Weg zu Java 21 LTS, somit empfiehlt sich sowieso eher Java 17 LTS.
1.2Inhaltsübersicht: Was erwartet Sie im Folgenden?
Dieses Buch gibt einen fundierten Überblick über diverse wesentliche Erweiterungen, die in Java 17 LTS und dem brandaktuellen Java 18 gebündelt sind. Es werden unter anderem die im Folgenden beschriebenen Themen behandelt. Ergänzend wagen wir einen kurzen Ausblick auf Java 19 und seine Neuerungen.
API- und Syntaxerweiterungen
Wir schauen uns verschiedene Änderungen an der Syntax von Java an. Wir beginnen mit sogenannten »Text Blocks«, die seit Java 13 mehrzeilige Strings erlauben. Im Kontext von instanceof ist es ab Java 14 möglich, künstliche Hilfsvariablen und unschöne Casts zu vermeiden. Auch bezüglich switch hat sich beginnend mit Java 12 einiges getan. Die neue Syntax erleichtert die Angabe und Auswertung von Bedingungen und sorgt für mehr Klarheit und Verständlichkeit. Zusätzlich bietet modernes Java seit Version 14 mit Records ein ganz besonders interessantes Feature, womit eine extrem kompakte Schreibweise zum Deklarieren spezieller Klassen mit unveränderlichen Daten bereitgestellt wird.
Darüber hinaus gibt es einige für die Praxis oft weniger relevante Dinge, wie die Unterstützung von lokalen Enums und Interfaces sowie statischer Attribute und Methoden in inneren Klassen seit Java 16 oder die Kontrolle von Vererbung durch Sealed Types seit Java 15. All dies komplettiert die Sprache und rundet sie ab. Neben diesen Details finden wir eine hilfreiche Neuerung zur Fehleranalyse bei NullPointerExceptions, die mit JDK 14 eingeführt wurde. Das ist eigentlich eine Erweiterung in der JVM, aber ich nenne sie trotzdem schon mal hier, weil es sich wie eine Syntaxerweiterung anfühlt.
Kommen wir zu den APIs: Hier finden wir Ergänzungen in der Klasse String sowie Kleinigkeiten im Interface Predicate<T> sowie der Klasse Optional<T>. Praktisch sind die Convenience-Funktionalitäten in der Utility-Klasse Files. Auch im Stream-API gibt es nennenswerte Neuerungen, unter anderem den Teeing-Kollektor sowie die Methoden toList() und mapMulti(). Eine herausragende Neuerung stellt das HTTP/2-API dar.
JVM-Änderungen
Mit Java 11 wurde ein neuer Garbage Collector eingeführt. Des Weiteren ermöglicht das Feature »Launch Single-File Source-Code Programs«, Java-Klassen ohne explizite vorherige Kompilierung auszuführen und somit für Scripting einsetzen zu können. Zudem kann für Quereinsteiger und Neulinge die durch das Tool jshell bereitgestellte Java-Konsole mit REPL-Unterstützung (Read-Eval-Print-Loop) erste Experimente und Gehversuche erleichtern, ohne dafür den Compiler oder eine IDE bemühen zu müssen. Java 12 bietet als wesentliche Neuerung die Integration des Microbenchmark-Frameworks JMH (Java Microbenchmarking Harness). Darüber hinaus behandle ich das Tool jpackage, mit dem sich eigene Applikationen als installierbare Distributionen erzeugen lassen. Plattformspezifisch entsteht somit etwa für Windows ein MSI-Installer (Microsoft Software Installation), für macOS ein DMG (Disk Image) und für Linux ein RPM (Red Hat Package Manager) – weitere Formate sind verfügbar.
Schließlich gibt es diverse Dinge, die aus dem JDK entfernt wurden: Unter anderem sind die Module zu CORBA, JavaFX und in Teilen auch zu XML, speziell JAXB (Jakarta XML Binding), nun nicht mehr Bestandteil des JDKs. Für einige davon zeige ich valide Alternativen und beschreibe etwa, wie man JAXB als externe Abhängigkeiten einbinden kann.
1.3Grundgerüst des Eclipse-Projekts
Das mitgelieferte Eclipse-Projekt orientiert sich in seinem Aufbau an dem des Buchs und bietet für die Kapitel jeweils ein eigenes Package, z. B. ch03_syntax oder ch05_api. Dabei weiche ich ausnahmsweise von der Namenskonvention für Packages ab, weil ich die Unterstriche in diesem Fall für eine lesbare Notation halte.
Das gesamte Projekt folgt dem Maven-Standardverzeichnisaufbau und somit finden sich die Sourcen unter src/main/java und die Tests unter src/test/java.
1.4Anmerkung zum Programmierstil
In diesem Abschnitt möchte ich vorab noch etwas zum Programmierstil sagen, weil bei Ihnen vielleicht ab und an einmal die Frage aufkommen mag, ob man gewisse Dinge nicht kompakter gestalten könnte oder sollte.
1.4.1Gedanken zur Sourcecode-Kompaktheit
In der Regel sind mir beim Programmieren und insbesondere für die Implementierungen in diesem Buch vor allem eine leichte Nachvollziehbarkeit sowie eine übersichtliche Strukturierung und damit später eine vereinfachte Veränderbarkeit wichtig. Deshalb sind die gezeigten Implementierungen möglichst verständlich programmiert. Dadurch ist vielleicht nicht jedes Konstrukt maximal kompakt, dafür aber in der Regel gut nachvollziehbar. Diesem Aspekt möchte ich in diesem Buch den Vorrang geben. Auch in der Praxis kann man damit oftmals besser leben als mit einer schlechten Wartbarkeit, dafür aber einer kompakteren Programmierung.
Beispiel
Schauen wir uns zur Verdeutlichung ein kleines Beispiel an. Zunächst betrachten wir die lesbare, gut verständliche Variante zum Umdrehen des Inhalts eines Strings, die zudem sehr schön die beiden wichtigen Elemente des rekursiven Abbruchs und Abstiegs verdeutlicht:
Die folgende deutlich kompaktere Variante bietet diese Vorteile nicht:
static String reverseStringShort(final String input)
{
return input.length() <= 1 ? input :
reverseStringShort(input.substring(1)) + input.charAt(0);
}
Überlegen Sie kurz, in welcher der beiden Methoden Sie sich sicher fühlen, eine nachträgliche Änderung vorzunehmen. Und wie sieht es aus, wenn Sie noch Unit Tests ergänzen wollen: Wie finden Sie passende Wertebelegungen und Prüfungen?
Außerdem sollte man bedenken, dass die obere Variante entweder bereits während der Kompilierung (Umwandlung in den Bytecode) oder später während der Ausführung und Optimierung automatisch in etwas Ähnliches wie die untere Variante konvertiert wird – eben mit dem Vorteil der besseren Lesbarkeit beim Programmieren.
1.4.2Gedanken zu final und var
Normalerweise bevorzuge ich, unveränderliche Variablen als final zu markieren. In diesem Buch verzichte ich mitunter darauf. Ein Grund ist, dass die JShell das Schlüsselwort final nicht überall unterstützt, glücklicherweise aber an den wichtigen Stellen, nämlich für Parameter und lokale Variablen.
Local Variable Type Inference – var
Seit Java 10 existiert die sogenannte Local Variable Type Inference, besser bekannt als var. Diese erlaubt es, auf die explizite Typangabe auf der linken Seite einer Variablendefinition zu verzichten, sofern sich der konkrete Typ für eine lokale Variable anhand der Definition auf der rechten Seite der Zuweisung vom Compiler ermitteln lässt:
Insbesondere im Zusammenhang mit generischen Containern spielt die Local Variable Type Inference ihre Vorteile aus:
Konvention: var, falls lesbarer
Sofern die Verständlichkeit darunter nicht leidet, werde ich var an geeigneter Stelle verwenden, um den Sourcecode kürzer und klarer zu halten. Ist jedoch eine Typangabe für das Nachvollziehen von größerer Wichtigkeit, bevorzuge ich den konkreten Typ und vermeide var – die Grenzen sind aber fließend.
Konvention: final oder var
Eine weitere Anmerkung noch: Zwar kann man final und var kombinieren, ich finde dies jedoch stilistisch nicht schön und verwende entweder das eine oder das andere.
1.4.3Blockkommentare in Listings
Beachten Sie bitte, dass sich in den Listings diverse Blockkommentare finden, die der Orientierung und dem besseren Verständnis dienen. In der Praxis sollte man derartige Kommentierungen mit Bedacht einsetzen und lieber einzelne Sourcecode-Abschnitte in Methoden auslagern. Für die Beispiele des Buchs dienen diese Kommentare aber als Anhaltspunkte, weil die eingeführten oder dargestellten Sachverhalte für Sie als Leser vermutlich noch neu und ungewohnt sind.
1.4.4Gedanken zur Formatierung
Die in den Listings genutzte Formatierung weicht leicht von den Coding Conventions von Oracle1 ab. Ich orientiere mich an denjenigen von Scott Ambler2, der insbesondere (öffnende) Klammern in jeweils eigenen Zeilen vorschlägt. Dazu habe ich ein spezielles Format namens Michaelis_CodeFormat erstellt. Dieses ist im Projekt-Download integriert und wird nachfolgend für eine Klasse demonstriert:
1.5Konfigurationen für Build-Tools und IDEs
Zur Demonstration der Auswirkungen von Java 17 auf Build-Tools und IDEs nehmen wir eine Beispielapplikation und ein paar einfache Beispielklassen mit folgendem Verzeichnisaufbau an:
Java17Examples
|-- build.gradle
|-- pom.xml
`-- src
`-- main
`-- java
|-- ch03_syntax
| |-- InstanceOfExamples.java
| |-- LocalEnumAndInterfaceExamples.java
| |-- RecordExamples.java
| |-- SealedTypesExamples.java
| `-- TextBlockExamples.java
...
Weil wir einige Aktionen auch auf der Kommandozeile ausführen, sei noch mal darauf hingewiesen, dass Sie zum Nachvollziehen
das aktuelle Java 17 heruntergeladen und installiert haben müssen sowie
die Umgebungsvariablen wie
JAVA_HOME
und
PATH
passend auf die Java-Installation verweisen lassen. Für macOS geschieht dies etwa wie folgt:
3
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH
1.5.1Java 17 mit Gradle
Zum Experimentieren mit Java 17 benötigt man zumindest Gradle 7.3 (oder neuer) und ein paar passende, nachfolgend fett markierte Angaben in der Datei build.gradle:
plugins {
id 'java'
}
sourceCompatibility=17
targetCompatibility=17
repositories
{
jcenter();
}
// Aktivierung von Preview-Features
tasks.withType(JavaCompile) {
options.compilerArgs += [" --enable-preview"]
}
Danach können wir wie gewohnt mit
gradle clean assemble
ein korrespondierendes JAR bauen und beispielsweise die Klasse TextBlockExamples folgendermaßen daraus starten:
java --enable-preview -cp build/libs/Java17Examples.jar \
java17.syntax.TextBlockExamples
Es ist wichtig, den JVM-Kommandozeilenparameter --enable-preview beim Start anzugeben. Denn nur dadurch lässt sich das Programm auch starten, wenn das Projekt mit Preview-Features kompiliert wurde.
1.5.2Java 17 mit Maven
Mit der im September 2020 veröffentlichten Maven-Version 3.6.3 (oder besser der im März 2022 veröffentlichten Version 3.8.5) und dem Maven-Compiler-Plugin in der Version 3.8.1 lassen sich Java-17-Projekte ohne Probleme übersetzen.
Um Java 17 mit Maven zu nutzen, muss man folgende fett markierte Angaben in der Datei pom.xml vornehmen:
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<release>17</release>
<!-- Aktivierung von Preview-Features -->
<compilerArgs>--enable-preview</compilerArgs>
</configuration>
</plugin>
</plugins>
Mit diesen Modifikationen lässt sich ein Maven-Build mit
mvn clean package
ausführen und es wird ein korrespondierendes JAR erzeugt.
Betrachten wir als Beispiel wieder den Start der Klasse TextBlockExamples:
java --enable-preview -cp target/Java17Examples-1.0.0-SNAPSHOT.jar \
java17.syntax.TextBlockExamples
1.5.3Java 17 mit Eclipse
Für Eclipse in Version 2022-03 ist der Support für Java 17 bereits integriert. Sofern Sie noch Eclipse 2021-09 nutzen, ist der Support durch die kurze Zeit zwischen der Veröffentlichung von Java 17 und Eclipse 2021-09 noch nicht fix integriert, sondern muss als Plugin über den Eclipse Marketplace nachinstalliert werden, wie es in Abbildung 1-2 angedeutet ist.
Abbildung 1-2Installation von Java-17-Plugin im Eclipse Marketplace
Selbstverständlich müssen Sie den Compiler auf Java 17 einstellen und die Preview-Features aktivieren, um alle Beispiele ausprobieren zu können.
Abbildung 1-3Compiler-Einstellungen in Eclipse für Java 17
1.5.4Java 17 mit IntelliJ
Um mit Java 17 zu experimentieren, nutzen Sie bitte IntelliJ IDEA 2021.2 oder aktueller. Allerdings sind noch ein paar Einstellungen vorzunehmen und folgende Dinge zu beachten:
Im Dialog »Project Structure« muss man im Bereich »
Project SDK
« den Wert 17 auswählen und zum Experimentieren mit Preview-Features im Bereich »
Language level
« den Wert »
17 (Preview) - Pattern matching for switch
« einstellen.
Durch die Nutzung von Preview-Features ist es für das Ausführen der Beispiele erforderlich, in der jeweiligen Run Configuration der zu startenden Klassen
--enable-preview
anzugeben.
Abbildung 1-4Einstellungen in Project Structure für Java 17
Oben ist die Standardeinstellung gezeigt, nachfolgend diejenige zur Aktivierung der Preview-Features:
Abbildung 1-5Einstellungen in Project Structure für Java 17 mit Preview
1.6Ausprobieren der Beispiele und Lösungen
Vielfach können Sie die abgebildeten Sourcecode-Schnipsel einfach in die JShell kopieren oder beispielsweise eine main()-Methode im Editor Ihrer IDE integrieren und danach ausführen. Alternativ finden Sie alle relevanten Sourcen in dem zum Buch mitgelieferten Eclipse-Projekt. Dort lassen sich die Programme durch eine main()-Methode starten.
Was gibt es noch zu beachten? Grundsätzlich verwende ich möglichst nachvollziehbare Konstrukte und keine ganz besonders ausgefallenen Syntax- oder API-Features. Sofern nicht explizit im Text erwähnt, sollten Sie die Beispiele und Lösungen daher mit der aktuellen LTS-Version Java 17 ausprobieren können. In wenigen Ausnahmen setze ich allerdings Preview-Syntaxerweiterungen aus Java 17 oder gar 18 ein. Erinnern wir uns: Durch die mittlerweile kurzen Abstände von 6 Monaten zwischen den Java-Releases werden der Entwicklergemeinde einige Features als Previews vorgestellt. Möchte man diese nutzen, so sind in den IDEs und Build-Tools gewisse Parametrierungen sowohl beim Kompilieren als auch beim Ausführen nötig, wie dies zuvor gezeigt wurde.
1.6.1Ausprobieren neuer Java-Features mit der JShell oder der Kommandozeile
Durch die recht eng getakteten Releasezyklen von 6 Monaten ist die Tool-Landschaft mitunter noch nicht immer parat, wenn man schon mal mit Vorabversionen experimentieren möchte. Dann bieten sich folgende Alternativen an:
Kommandozeile – Selbstverständlich ist es immer möglich, mit
javac
und
java
zu arbeiten, wenn auch manchmal etwas mühsamer.
Kommandozeile – Seit Java 11 gibt es das Feature, einzelne Java-Dateien direkt durch Aufruf von
java
, also ohne explizites vorheriges Kompilieren, starten zu können (vgl.
Abschnitt 7.3
).
JShell – Die JShell ist seit Java 9 eine Alternative für kleine Experimente, weil das REPL-Tool (Read-Eval-Print-Loop) Bestandteil der JVM ist und das Ausführen kleinerer Sourcecode-Schnipsel erlaubt.
Ausführen mit der Kommandozeile
Wie gerade erwähnt, kann man einzelne Java-Dateien direkt durch Aufruf von java, also ohne explizites vorheriges Kompilieren, starten. Das Editieren kann mit jedem beliebigen Texteditor oder einer IDE (gegebenenfalls mit der Markierung von Syntaxfehlern) erfolgen.
Betrachten wir exemplarisch ein Beispielprogramm:
import java.time.Duration;
import java.time.temporal.ChronoUnit;
public class DurationIntroExample
{
public static void main(String[] args)
{
System.out.println(Duration.of(20L, ChronoUnit.DAYS).isNegative());
System.out.println(Duration.of(-12L, ChronoUnit.DAYS).isNegative());
}
}
Dieses einfache aus einer Klasse bestehende Programm lässt sich ohne explizite Kompilierung direkt von der Konsole starten:
$ java src/main/java/intro/DurationIntroExample.java
Dann erhalten wir diese Ausgabe:
false
true
Ausführen mit der jshell
Mit der JShell wird es möglich, etwas Java-Sourcecode zu schreiben und Dinge schnell auszuprobieren, ohne dafür die IDE starten und ein Projekt anlegen zu müssen. Außerdem kann man immer auch die neuesten Features ausprobieren. Etwas detaillierter gehe ich in Abschnitt 7.2 auf die Möglichkeiten ein. Hier folgt ein einführendes Beispiel, um Sie für das Ausführen einzelner Kommandos vorzubereiten.
Starten wir die jshell und probieren einige Aktionen und Berechnungen aus. Dabei dient eine Abwandlung eines Hello-World-Beispiels als Startpunkt:
$ jshell
| Welcome to JShell -- Version 17.0.2
| For an introduction type: /help intro
jshell> System.out.println("Hello JShell")
Hello JShell
Danach addieren wir zwei Zahlen:
jshell> 2 + 2
$2 ==> 4
Anhand der Ausgabe sehen wir, dass die jshell das Berechnungsergebnis einer Shell-Variablen zuweist, die mit $ beginnt, hier $2.
Tipp: Besonderheit Preview-Features
Sofern Sie mit Preview-Features experimentieren möchten, müssen Sie diese geeignet aktivieren, etwa wie folgt in der JShell:
$ jshell --enable-preview
Auch die Definition eigener Methoden ist folgendermaßen möglich:
jshell> int add(int a, int b) {
...> return a + b;
...> }
| created method add(int,int)
Praktischerweise erkennt die jshell, dass die Anweisungen nicht vollständig sind und noch weitere Eingaben in einer Folgezeile benötigt werden. Erst nach erfolgreichem Abschluss der Methode kommt es zur gezeigten Meldung »created method add(int,int)«.
Wollten wir das vorherige Beispiel zu der Neuerung in der Klasse Duration mit der JShell nachvollziehen, so benötigen wir zunächst zwei Imports – bei einzelnen Anweisungen lässt sich sogar auf das abschließende Semikolon verzichten:
jshell> import java.time.Duration
jshell> import java.time.temporal.ChronoUnit
Statt einer main()-Methode können wir die einzelnen Aufrufe direkt ausführen:
jshell> System.out.println(Duration.of(20L, ChronoUnit.DAYS).isNegative())
false
jshell> System.out.println(Duration.of(-12L, ChronoUnit.DAYS).isNegative())
true
Auch Schleifen und sogar deutlich komplexere Aktionen sind möglich, wie es hier nachfolgend nur angedeutet ist:
1.6.2Ausprobieren neuer Java-Features in einer Sandbox
Durch die häufigen Releasewechsel und die ständig neu zu installierenden Versionen ist man mitunter noch nicht auf dem aktuellsten Stand oder vielleicht möchte man schon einmal ein Feature ausprobieren, noch bevor das offizielle Release erschienen ist. Interessanterweise bietet die Seite https://javaalmanac.io/
