Java Entwickler Experte
Java JDK: Überblick über Versionen, Unterschiede zwischen LTS, SE, JRE und Java 24
Wir bieten dir einen Überblick über die Java-Versionen, einen Vergleich von Java JDK-, SE- und LTS-Releases sowie eine Zusammenfassung der wichtigsten Änderungen in den neuesten Versionen – einschließlich Java 24, das die Grenzen der Sprache erneut ein Stück weiter verschiebt. So erhältst du ein klares Bild davon, welche Hauptunterschiede zwischen den Versionen bestehen, welche neuen Funktionen sie bieten und worauf du bei einer Migration achten solltest.
In diesem Artikel erfährst du:
Java-Versionen JDK, SE, LTS und Veröffentlichungsfrequenz
Java wird seit über zwei Jahrzehnten kontinuierlich weiterentwickelt, und um mit den modernen Anforderungen der Softwareentwicklung Schritt zu halten, ist die Sprache auf ein halbjährliches Release-Modell umgestiegen. Die erste agile Version war Java SE 9, die im September 2017 veröffentlicht wurde. Version Java 10 erschien dann ein halbes Jahr später. Seitdem erscheint alle sechs Monate eine neue Version des Java JDK, die Verbesserungen, Fehlerbehebungen und experimentelle Funktionen mit sich bringt.
Für Unternehmen und Entwickler ist es entscheidend, den Unterschied zwischen LTS-Versionen (Long-Term Support), die Stabilität und langfristige Unterstützung gewährleisten, und Non-LTS-Versionen zu verstehen, die eher für das Testen neuer Funktionen und die Vorbereitung auf zukünftige LTS-Releases gedacht sind.
Java JDK (Java Development Kit)
Das Java JDK (Java Development Kit) ist das offizielle Werkzeugpaket zur Entwicklung von Anwendungen in Java. Es enthält den Compilerjavac, der Quellcode in Bytecode übersetzt, der auf der Java Virtual Machine (JVM) ausgeführt werden kann, sowie einen Debugger, die Standard-API-Bibliotheken, Dokumentation und verschiedene Tools zur Verwaltung und zum Testen von Anwendungen. Das JDK ist somit unverzichtbar für jeden Entwickler, da es eine vollständige Umgebung zum Schreiben, Kompilieren, Ausführen und Debuggen von Code bereitstellt.
Neben den grundlegenden Werkzeugen bietet das JDK auch verschiedene Hilfsprogramme wie javadoc zum Erzeugen von Dokumentation direkt aus dem Quellcode oder jlink zum Erstellen eigener Java-Laufzeit-Images. Es ist wichtig, das JDK vom JRE (Java Runtime Environment) zu unterscheiden, das ausschließlich zum Ausführen bereits fertiger Anwendungen dient. Während das JRE von Endbenutzern verwendet wird, ist das JDK in erster Linie für Entwickler gedacht – ohne es wäre die Erstellung und das Testen von Java-Anwendungen nicht möglich.
Java SE (Java-Plattform, Standard Edition)
Java SE (Java Platform, Standard Edition) ist die grundlegende Edition der Java-Plattform, die die standardisierte API, Syntax und das Verhalten der Sprache definiert. Sie enthält die wichtigsten Bibliotheken und Pakete, wie Collections, Concurrency, I/O, Networking, Security oder XML-Verarbeitung. Dank Java SE entsteht die gemeinsame Grundlage, auf der alle Java-Anwendungen und Frameworks basieren – von einfachen Desktop-Programmen bis hin zu umfangreichen Enterprise-Lösungen.
Java SE ist kein Entwicklungswerkzeug wie das JDK, sondern eher ein „Standard“ und eine Spezifikation dessen, was jede Java-Version enthalten muss. Es ist die offizielle Definition der Sprache, die alle Java-Implementierungen (z. B. OpenJDK) einhalten müssen. Für Entwickler bietet sie die Sicherheit, dass Code, der gemäß Java SE geschrieben wurde, in jeder mit diesem Standard kompatiblen Umgebung funktioniert.
JRE (Java Runtime Environment)
Das Java Runtime Environment (JRE) ist eine Laufzeitumgebung zur Ausführung von in Java geschriebenen Anwendungen. Es enthält die Java Virtual Machine (JVM), die für die Übersetzung und Ausführung des Bytecodes verantwortlich ist, sowie die grundlegenden Bibliotheken, die für den Betrieb von Programmen erforderlich sind. Im Gegensatz zum JDK bietet das JRE keine Entwicklungswerkzeuge – seine Aufgabe besteht ausschließlich darin, sicherzustellen, dass eine fertige Anwendung auf einem Computer oder Server ausgeführt werden kann.
Das JRE eignet sich daher für Endbenutzer oder Produktionsumgebungen, in denen Anwendungen lediglich ausgeführt, aber nicht weiterentwickelt werden. Ein Entwickler kommt in der Regel mit dem JDK aus (das das JRE automatisch enthält), während das JRE allein von denen genutzt wird, die Anwendungen nur betreiben.
Java LTS (Long-Term Support)
Java LTS (Long-Term Support) steht für Java-Versionen, die eine garantierte langfristige Unterstützung von Oracle oder anderen Anbietern (Adoptium, Red Hat usw.) erhalten. Jede LTS-Version erscheint ungefähr alle drei Jahre und bietet Unternehmen Stabilität, Sicherheitsupdates und Fehlerbehebungen über einen Zeitraum von 8 oder mehr Jahren. Genau deshalb sind LTS-Releases die häufigste Wahl für Enterprise-Projekte, bei denen Zuverlässigkeit und minimales Risiko im Betrieb entscheidend sind.
Im Gegensatz zu non-LTS-Versionen, die nur 6 Monate lang unterstützt werden und hauptsächlich zum Testen neuer Funktionen dienen, fungieren LTS-Versionen als stabile Meilensteine in der Geschichte von Java. Entwickler und Unternehmen migrieren in der Regel direkt von einer LTS-Version zur nächsten (z. B. von Java 11 auf 17 oder 21), um Probleme mit kurzlebigen Releases zu vermeiden. LTS bildet somit eine sichere Grundlage für langfristige Projekte und Produktionsumgebungen.
Unterschiede zwischen Java JDK, SE, LTS, JRE
| Kriterium | LTS (Long-Term Support) | non-LTS | JDK (Java Development Kit) | Java SE (Standard Edition) | JRE (Java Runtime Environment) |
|---|---|---|---|---|---|
| Dauer des Supports | 8+ Jahre (Oracle, Hersteller-Support) | 6 Monate | Enthält den Compiler javac, Tools, Debugger, Dokumentation, Bibliotheken |
Plattform und API durch Standard definiert (JLS, JVM, Bibliotheken) | Enthält JVM + Basisbibliotheken, ohne Entwickler-Tools |
| Veröffentlichung | Alle 3 Jahre (z.B. Java 11, 17, 21) | Halbjährlich (z.B. Java 12, 13, 14…) | Wird mit jeder Java-Version ausgeliefert (LTS und non-LTS) | Definiert, was jede Java-Version „haben muss“ | An eine bestimmte Java-Version gebunden, wird zusammen mit dem JDK veröffentlicht |
| Stabilität | Sehr stabil, empfohlen für Unternehmen und Produktion | Experimenteller, bringt neue Features schneller | Bietet alle Entwicklungswerkzeuge für Java | Enthält Basis-API (Collections, Streams, IO, Concurrency usw.) | Stabile Laufzeitumgebung für Anwendungen |
| Zielgruppe | Konzerne, Enterprise-Lösungen, langfristige Projekte | Entwickler, Test neuer Features | Programmierer und Entwicklerteams | Ganze Java-Community (Standardisierung) | Endbenutzer und Umgebungen, in denen Anwendungen nur ausgeführt werden |
| Risiko | Minimal, langfristige Fixes und Sicherheitsupdates | Höher – Feature kann in der nächsten Version entfernt werden | Kein zusätzliches Risiko – an Version gebunden | Stabilität – definiert die offizielle Grundlage von Java | Kein Risiko – keine Entwickler-Tools, nur Runtime |
| Beispiele | Java 8, Java 11, Java 17, Java 21 | Java 9, 10, 12, 13, 14, 15, 16, 18… | JDK 11, JDK 16, JDK 24… | Java SE 9, SE 18, SE 25… | JRE 8, JRE 11, JRE 17… |
LTS-Versionen sind die Wahl für Stabilität und langfristige Unterstützung. Unternehmen setzen sie in der Produktion ein, weil sie über viele Jahre Sicherheitsupdates und Fehlerbehebungen erhalten.
Non-LTS-Versionen hingegen sind kurzlebig – sie erscheinen alle sechs Monate und bringen schnellere Innovationen. Entwickler nutzen sie, um neue Funktionen zu testen, aber in der Produktion wird meist auf die nächste LTS-Version gewechselt.
Das JDK (Java Development Kit) ist ein Werkzeugpaket, das du mit jeder Java-Version erhältst und das direkt für Entwickler gedacht ist.
Java SE (Standard Edition) definiert den grundlegenden Sprachstandard und das API, auf dem das gesamte Java-Ökosystem aufbaut.
- LTS-Versionen → Stabilität, langfristige Unterstützung, geeignet für Produktion
- non-LTS-Versionen → Kurzlebig, bringen neue Funktionen, geeignet zum Testen
- JDK (Java Development Kit) → Werkzeuge für Entwickler (Compiler, Debugger, Bibliotheken)
- Java SE (Standard Edition) → Basisstandard und API, Fundament des gesamten Java-Systems
Wenn du dich also fragst, welche Version du wählen sollst:
- Für ein langfristiges Projekt greif zu einer LTS-Version.
- Für Experimente und schnelle Einführung neuer Features eignet sich non-LTS.
Migration zwischen Java JDK-Versionen
Die Migration auf eine neue Java-Version bedeutet nicht nur, das neueste JDK herunterzuladen. Es ist ein Prozess, der Planung, Tests und Anpassung des bestehenden Codes erfordert.
Hauptschritte der Migration:
- Projekt-Analyse
- Prüfe, welche Bibliotheken und Frameworks du verwendest.
- Überprüfe, ob sie mit der Zielversion von Java kompatibel sind.
- Überprüfung veralteter und entfernter APIs
- In neuen Versionen werden manche Funktionen als deprecated markiert und später ganz entfernt..
- Typische Beispiele: alte Sicherheitsalgorithmen, interne APIs wie sun.*.
- Kompatibilitätstests
- Führe bestehende Tests mit der neuen JDK-Version aus.
- Achte auf Warnungen und Fehler beim Kompilieren.
- Anpassung des Builds und der CI/CD-Pipeline
- Aktualisiere Build-Tools (Maven, Gradle).
- Stelle sicher, dass die CI/CD-Pipeline auf der richtigen JDK-Version läuft.
- Schrittweiser Übergang
- Bei großen Projekten empfiehlt es sich, von LTS zu LTS zu wechseln (z. B. von 11 → 17 → 21).
- So vermeidest du Zwischenversionsprobleme und erhältst Stabilität.
- Performance- und Regressionstests
- Teste die Anwendung unter Last, um mögliche Verlangsamungen oder Memory Leaks zu erkennen.
Häufige Probleme bei der Migration:
- Nicht unterstützte Bibliotheken – ältere Dependencies funktionieren eventuell nicht mehr mit dem neuen JDK.
- Entfernte APIs – wenn das Projekt interne JDK-APIs nutzt, kann das zu Fehlern führen.
- Sicherheitsänderungen – strengere TLS/SSL-Einstellungen können ältere Verbindungen blockieren.
Am sichersten ist es, immer auf die neueste LTS-Version zu migrieren, die Anwendung gründlich zu testen und sie dann in die Produktion zu bringen. Non-LTS-Versionen sind ideal für Experimente, aber nicht für den langfristigen Betrieb von Anwendungen.
Als nächstes werden wir die Änderungen und Verbesserungen in jeder Java-Version im Detail besprechen.
Java SE 24
Java 24 bringt die neue Version JDK 24 mit symbolischen 24 Verbesserungen in Sprache, API, Plattformleistung, Stabilität und Sicherheit. Eine so umfangreiche und aufregende Veröffentlichung gab es schon lange nicht mehr. Also verlieren wir keine Zeit und schauen uns die Neuerungen Schritt für Schritt an.
Java JDK 24 bringt zahlreiche Änderungen und Verbesserungen
Die neue Version Java 24 wurde von Oracle am 18. März 2025 veröffentlicht. Das vollständige Entwicklerpaket Java Development Kit 24 (JDK 24) für diese Java-Version bietet zahlreiche Verbesserungen für Programmierer.
Wir empfehlen Ihnen…
Java 24 einschließlich der Release Notes steht unter diesem Link zum Download bereit.
Wie auch die vorherigen Java-Versionen ist Java 24 das Ergebnis gemeinsamer Anstrengungen vieler Mitwirkender – sowohl einzelner Personen als auch Organisationen der OpenJDK-Community. Während die Anzahl der Änderungen in den JDK-Veröffentlichungen seit mehreren Jahren ungefähr gleich bleibt, hat sich im letzten sechsmonatigen Zyklus das Tempo, mit dem neue Funktionen und Verbesserungen in die Produktion gelangen, deutlich beschleunigt.
Die Änderungen in JDK 24 reichen von bedeutenden neuen Funktionen über kleinere Verbesserungen bis hin zu routinemäßiger Wartung, Fehlerbehebungen und Dokumentationsupdates. Jede Änderung für ein bestimmtes Ticket wird durch einen separaten Commit im JDK Bug System-Repository repräsentiert.
Wusstest du, dass…
…zwischen den Versionen Java 11 und Java 24 insgesamt 31 187 Probleme gelöst wurden? 22 107 (ca. 70 %) davon wurden von Oracle-Mitarbeitern, 9080 (ca. 30 %) von einzelnen Entwicklern, die entweder selbstständig oder für andere Organisationen arbeiten, gelöst. In Java 24 wurden von den 2.463 als behoben markierten JIRA-Problemen 1.657 (ca. 67 %) von Oracle und 806 (ca. 33 %) von anderen Mitgliedern der Java-Community behoben.
JDK 24 bringt 24 Verbesserungen, die bedeutend genug sind, um eigene JDK Enhancement Proposals (JEPs) zu erhalten – darunter 8 Preview-Features und 1 Incubator-Feature.
Sprachfunktionen in Oracle JDK 24
Primitive types in patterns, instanceof und switch (Vorschau 2)
JEP 488: Erweitert Pattern Matching, um Typmuster mit primitiven Typen in allen Kontexten zu ermöglichen, und ergänzt die Operatoren instanceof und switch um Unterstützung für alle primitiven Typen einschließlich sicherer Tests und Konvertierungen. Das führt zu einer vereinheitlichten, ausdrucksstärkeren Sprache für den Umgang mit Werten und Typen, ohne manuelle Typumwandlungen oder Bereichsprüfungen.
Flexible constructor bodies (Vorschau 3)
JEP 492: Erlaubt das Einfügen von normalen Anweisungen vor einem expliziten super(…) oder this(…)-Aufruf im Konstruktor-Rumpf. Diese Anweisungen dürfen Felder initialisieren und Argumente validieren, aber keinen noch nicht fertiggestellten Objektzustand verwenden. Das führt zu einem natürlicheren Modell für Validierung und Datenvorbereitung vor der Erzeugung einer Oberklasse und macht Konstruktoren klarer und einfacher.
Module import declarations (Vorschau 2)
JEP 494: Führt eine neue Syntax import module M; ein, die alle öffentlichen Top-Level-Klassen und -Schnittstellen importiert, die vom Modul M exportiert werden (einschließlich transitiver Abhängigkeiten). Das beseitigt die Notwendigkeit mehrerer import … .*-Anweisungen und vereinfacht die Wiederverwendung modularer Bibliotheken in allen Projekttypen erheblich.
Simple source files and instance main methods (Vorschau 4)
JEP 495: Bietet eine einfachere Möglichkeit, kleine Java-Programme zu erstellen: Erlaubt ausführbare Programme ohne eigene Klasse und ohne den Boilerplate public static void main(String[] args). Unterstützt instanzbasierte main-Methoden (ohne Parameter und Modifikatoren) sowie einfache Quelldateien mit automatischen Importen der Grund-I/O-Methoden und des gesamten Moduls java.base. Das reduziert die Lernkurve und ermöglicht den nahtlosen Übergang zu vollwertigen Programmen.
Bibliotheken in Oracle JDK 24
Class‑file API
JEP 484: Führt ein standardisiertes API (java.lang.classfile) zum Parsen, Erzeugen und Transformieren von .class-Dateien gemäß der JVM-Spezifikation ein. Ziel ist es, interne ASM-Bibliotheken durch eine einheitliche, wartbare und voll spezifizierte Schnittstelle zu ersetzen.
Stream gatherers
JEP 485: Erweitert das Stream-API um die Möglichkeit, eigene intermediate Operationen (Stream::gather) zu definieren, die maßgeschneiderte Transformationen (One-to-One, One-to-Many, Many-to-Many) mit voller Parallelisierungsunterstützung ermöglichen. Das vereinfacht ausdrucksstarke und effiziente Datenverarbeitungspipelines.
Scoped values (Vorschau 4)
JEP 487: Führt den neuen Typ ScopedValue ein, um unveränderliche (immutable) Daten innerhalb einer Methode, ihrer Aufrufe und neu erstellter Threads zu teilen – eine einfachere und leistungsfähigere Alternative zu ThreadLocal. Er bietet geringeren Speicher- und Zeitaufwand und ist besonders nützlich bei virtuellen Threads.
Vektor-API (9. Inkubator)
JEP 489: Bietet eine plattformneutrale, leistungsstarke Schnittstelle zur Darstellung von Vektorberechnungen, die während der Ausführung auf native SIMD-Befehle auf unterstützten CPUs abgebildet werden. Dadurch können Entwickler eine bessere Leistung erzielen als mit äquivalenten Skalarberechnungen, die zunehmend in KI-Berechnungen verwendet werden.
Structured concurrency (Vorschau 4)
JEP 499: Ermöglicht die Verwaltung von Gruppen zusammenhängender Aufgaben als eine einzige Arbeitseinheit über eine neue API, was das Fehlermanagement, die Aufhebung und die Beobachtbarkeit in nebenläufigen Anwendungen vereinfacht. Dieses Konzept hilft, „Thread-Leaks“ zu vermeiden und verbessert die Zuverlässigkeit und Lesbarkeit des Codes.
Sicherheitsbibliotheken von Oracle JDK 24
Key derivation function API (Vorschau)
JEP 478: Führt eine neue API javax.crypto.KDF zur Erzeugung und Erweiterung kryptographischer Schlüssel unter Verwendung standardisierter KDF-Algorithmen wie HKDF (RFC 5869) und Argon2 (RFC 9106) ein. Ermöglicht es Anwendungen, mehrere Schlüssel aus einem einzigen geheimen Eingabeschlüssel abzuleiten (z. B. in Hybrid Public Key Encryption oder TLS 1.3) und bietet eine Schnittstelle für Erweiterbarkeit durch weitere KDF-Implementierungen.
Quantum‑resistant module‑lattice‑based key encapsulation mechanism
JEP 496: Liefert eine Implementierung von ML-KEM, einem quantenresistenten KEM-Schema, das in NIST FIPS 203 standardisiert wurde. Erweitert KeyPairGenerator, KEM und KeyFactory um Parametersätze ML-KEM-512, ML-KEM-768 und ML-KEM-1024, wodurch Anwendungen symmetrische Schlüssel sicher austauschen können, die gegen Angriffe zukünftiger Quantencomputer resistent sind.
Quantum‑resistant module‑lattice‑based digital signature algorithm
JEP 497: Fügt Unterstützung für ML-DSA hinzu, einen quantenresistenten Algorithmus für digitale Signaturen (FIPS 204). Implementiert KeyPairGenerator, Signature und KeyFactory für drei Parametersätze: ML-DSA-44, ML-DSA-65 und ML-DSA-87, was Authentifizierung und Datenintegritätsprüfung mit Widerstandsfähigkeit gegen Quantenangriffe ermöglicht.
Werkzeuge von Oracle JDK 24
Linking run‑time images without JMODs
JEP 493: Ermöglicht es, mit dem Tool jlink Laufzeit-Images ohne JMOD-Dateien zu erstellen, reduziert die JDK-Installationsgröße um bis zu 25 % und vereinfacht die Modulverwaltung in Cloud- und Container-Umgebungen.
Leistungsverbesserungen zur Laufzeit in Oracle JDK 24
Compact object headers (experimentell)
JEP 450: Reduziert die Größe von Java-Objekt-Headern von 96–128 Bit auf 64 Bit auf 64-Bit-Plattformen, spart Speicher und verbessert die Datenlokalität im Cache. Aktivierung durch VM-Optionen:
-XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders.
Late barrier expansion for G1
JEP 475: Verschiebt die Expansion von Speicherbarrieren im G1 GC von frühen Phasen der C2-Kompilierung in spätere, wodurch die Kompilierungszeit verkürzt und die Implementierung vereinfacht wird, während die Leistung des generierten Codes erhalten bleibt.
Ahead‑of‑time class loading & linking
JEP 483: Verbessert den JVM-Start, indem während einer Ausführung geladene und vorverknüpfte Klassen im Cache gespeichert werden, den HotSpot beim nächsten Start verwendet, wodurch die Startzeit verkürzt wird.
ZGC: Remove the non‑generational mode
JEP 490: Entfernt den Non-Generational-Modus des Z Garbage Collectors (-XX:+ZGenerational), reduziert die Codekomplexität und macht den generational ZGC zum primären Modus, der für die meisten Einsätze besser geeignet ist.
Synchronize virtual threads without pinning
JEP 491: Verbessert die Skalierbarkeit synchronisierter Blöcke bei der Verwendung virtueller Threads, indem bei einer Blockierung kein Plattform-Thread gehalten, sondern freigegeben wird, sodass mehr virtuelle Threads gleichzeitig bedient werden können.
Quellcode von Oracle JDK 24
Generational Shenandoah (experimentell)
JEP 404: Führt einen experimentellen generationalen Modus in den Shenandoah GC ein, der die nachhaltige Durchsatzleistung, die Belastbarkeit bei plötzlicher Last und die Speichernutzung verbessert, indem der Heap in Generationenbereiche aufgeteilt wird, ohne den bestehenden nicht-generationalen Modus zu beeinträchtigen. Ziel ist es, den generationalen Shenandoah in zukünftigen Versionen als Standardmodus vorzubereiten.
Prepare to restrict the use of JNI
JEP 472: Führt zur Laufzeit Warnungen bei Aufrufen von JNI und des Foreign Function & Memory API ein, um Entwickler auf eine kommende Version vorzubereiten, die die implizite native Interaktion einschränken oder deaktivieren wird. JNI bleibt verfügbar, jedoch mit klaren Warnungen und einheitlichem Verhalten vor dem Übergang zu strengeren Beschränkungen.
Remove the Windows 32‑bit x86 port
JEP 479: Entfernt Quellcode und Build-Skripte für den Windows 32-bit x86-Port (deprecated in JDK 21), wodurch alle spezifischen Pfade und Tests für diesen Port eliminiert werden. Nach dem Ende der Unterstützung für Windows 10 32-bit (EOL Oktober 2025) wird die Build- und Testinfrastruktur des JDK vereinfacht.
Permanently disable the security manager
JEP 486: Die Plattform-Spezifikation wird so angepasst, dass der Security Manager nicht mehr aktiviert werden kann und seine API im Code nicht mehr referenziert wird. Dadurch wird der veraltete und aufwendige Sicherheitsmechanismus entfernt, der bereits in Java 17 deprecated war.
Warn upon use of memory‑access methods in sun.misc.Unsafe
JEP 498: Beim ersten Aufruf einer beliebigen Memory-Access-API in sun.misc.Unsafe gibt die JVM eine Laufzeitwarnung aus. Diese Methoden wurden in JDK 23 deprecated und sollen durch standardisierte Kryptographie- und Speicher-APIs ersetzt werden.
Deprecate the 32‑bit x86 port for removal
JEP 501: Markiert den letzten 32-bit x86-Port (Linux) als deprecated und bereitet dessen vollständige Entfernung in JDK 25 vor. Nach der Entfernung bleibt für 32-bit-Architekturen nur der architekturunabhängige Zero-Port erhalten.
Quellen:
- https://blogs.oracle.com/java/post/the-arrival-of-java-24
- https://openjdk.org/projects/jdk/24/
Java SE 23
Java als Programmiersprache dominiert weiterhin die heutigen technologischen Trends. Auch die Veröffentlichung von Java 23 mit zahlreichen Verbesserungen zeigt, dass durchdachte Planung sowie festgelegte und eingehaltene Termine dazu beitragen, dass Java mit seinem Ökosystem für viele Entwickler weltweit zur bevorzugten Plattform für moderne Softwareentwicklung geworden ist.
Überblick über die Verbesserungen der Programmiersprache Java (JEPs) der letzten 10 Jahre
Java 23 SE
Java 23 wurde am 17. September 2024 veröffentlicht. Wie bei den vorherigen Java-Releases ist Java 23 das kollektive Ergebnis von Beiträgen, sowohl einzelner Personen als auch von Organisationen der OpenJDK-Community.
Die Anzahl der Änderungen in den JDK-Updates ist in den letzten Jahren weitgehend konstant geblieben (im Durchschnitt etwa 10), was auf die regelmäßigen sechsmonatigen Veröffentlichungen zurückzuführen ist. Trotz der relativ kurzen Vorbereitungszeit reichen die Änderungen von neuen Sprachfunktionen über kleine Verbesserungen der bestehenden Funktionalität bis hin zu Fehlerbehebungen und Dokumentationsaktualisierungen.
Jede Änderung für ein bestimmtes Ticket wird durch einen separaten Commit im JDK Bug System-Repository dargestellt. Interessant ist, dass zwischen den Versionen Java 11 bis Java 23 insgesamt 28.724 Probleme gelöst wurden, wobei 20.450 (ca. 71 %) von Mitarbeitern von Oracle und 8.274 (ca. 29 %) von einzelnen Java-Programmierern, die entweder selbstständig oder für andere Organisationen arbeiten, stammen.
Primitive Typen in Mustern, instaceof und switch (Vorschau)
Diese Änderung (JEP 455) beseitigt mehrere Einschränkungen, die bei der Verwendung primitiver Typen in Mustervergleichen bestehen. Code, der primitive Typen und Objekttypen verarbeitet, kann vereinfacht werden, wenn keine speziellen Anpassungen erforderlich sind und beide Typen auf die gleiche Weise behandelt werden können. Die Möglichkeit, dass
instanceof
-Instanzen auch Primitive akzeptieren, reduziert den Code weiter, da nun automatische bedingte Typumwandlungen unterstützt werden – also Fälle, in denen überprüft werden muss, ob ein Wert für den Zieltyp gültig ist.
Modulimport-Deklarationen (Vorschau)
JEP 476 – ermöglicht es Entwicklern, alle von einem Modul exportierten Pakete mit einem einzigen Befehl zu importieren. Das vereinfacht die Wiederverwendung modularer Bibliotheken, ohne dass der importierte Code selbst im Modul enthalten sein muss. Dank dieser Funktion können Einsteiger Bibliotheken von Drittanbietern und grundlegende Java-Klassen verwenden, ohne lernen zu müssen, wo sie sich in der Paket-Hierarchie befinden.
Implizit deklarierte Klassen und main-Methoden-Instanz (Dritte Vorschau)
JEP 477 – Dies ermöglicht es Einsteigern, ihre ersten Java-Programme zu schreiben, ohne zunächst die für größere und komplexere Programme bestimmten Funktionen verstehen zu müssen. Einfache Programme können vereinfachte Deklarationen verwenden und bei Bedarf problemlos um fortgeschrittene Funktionen erweitert werden. Auch erfahrene Entwickler können das kompakte Schreiben kleiner Programme genießen.
Flexible Konstruktor-Körper (zweite Vorschau)
JEP 482 – Indem erlaubt wird, dass bestimmte Anweisungen in Konstruktoren vor dem expliziten Aufruf des Konstruktors, also super(…) oder this(…), erscheinen dürfen, erhalten Entwickler mehr Freiheit, das Verhalten von Konstruktoren besser auszudrücken. Die natürlichere Platzierung der Logik, die diese Funktion bietet, beseitigt die Notwendigkeit, Teile der Prüf- und Initialisierungslogik in Hilfsmethoden oder Hilfskonstruktoren auszulagern. Zum Beispiel kann ein Konstruktor empfangene Argumente prüfen, bevor er den Superklassen-Konstruktor aufruft, wodurch ein schnelles Scheitern ermöglicht und unnötige Instanzen der Superklasse vermieden werden, wenn die Argumente ungültig sind.
Class-file-API (zweite Vorschau)
JEP 466 – Dieser JEP schlägt eine API zur Analyse, Erzeugung und Transformation von Java-Klassendateien vor, die dem von der Java Virtual Machine-Spezifikation definierten Format folgt. Wenn diese API als Bestandteil jeder JDK-Version ausgeliefert wird, verringert sich die Spannung, die dadurch entsteht, dass Java auf einen sechsmonatigen Veröffentlichungszyklus umgestellt hat, während Frameworks, die mit Klassendateien arbeiten, ihre Bibliotheken bei jeder Version aktualisieren müssen, um neue Versionen schnell unterstützen zu können. Nach ihrer Fertigstellung sollte diese Funktionalität das JDK selbst von seiner Abhängigkeit von der externen ASM-Bibliothek befreien.
Vector-API (achte Inkubation)
JEP 469 – ermöglicht es Java-Entwicklern, Vektorberechnungen auszudrücken, die zur Laufzeit zuverlässig in optimale Vektorinstruktionen auf unterstützten CPU-Architekturen kompiliert werden, wodurch eine bessere Leistung als bei äquivalenten skalaren Berechnungen erzielt wird. Es gibt keine Unterschiede zur siebten Inkubation dieser Funktion in JDK 22. Es wird erwartet, dass diese API weiterhin als inkubierend zurückkehrt, höchstens mit kleinen Änderungen, bis die erforderlichen Funktionen aus dem Projekt Valhalla verfügbar sind.
Stream gatherers (zweite Vorschau)
JEP 473 – verbessert die Stream-API, um benutzerdefinierte Zwischenoperationen zu unterstützen. Das ermöglicht es Stream-Pipelines, Daten auf Weisen zu transformieren, die mit den vorhandenen eingebauten Zwischenoperationen nicht leicht erreichbar sind. Stream-Gatherer bieten für Zwischenoperationen eine Flexibilität, die Sammler (Collectors) für Endoperationen bieten. Diese Verbesserung führt fünf eingebaute Gatherer ein.
Strukturierte Nebenläufigkeit (dritte Vorschau)
JEP 480 – Strukturierte Nebenläufigkeit ermöglicht es Entwicklern, Gruppen zusammengehöriger Aufgaben, die in verschiedenen Threads ausgeführt werden, als eine einzige Arbeitseinheit zu behandeln. Dadurch wird die Fehlerbehandlung und das Abbrechen vereinfacht, die Zuverlässigkeit erhöht und die Beobachtbarkeit verbessert. Diese API unterstützt einen Stil des nebenläufigen Programmierens, der häufige Risiken im Zusammenhang mit Abbrüchen und Abschaltungen, wie Thread-Lecks und Verzögerungen beim Abbrechen, eliminieren kann.
Scoped values (dritte Vorschau)
JEP 481 – ermöglicht es einer Methode, unveränderliche Daten mit ihren Aufrufern innerhalb eines Threads sowie mit untergeordneten Threads zu teilen. Die Verwendung von Scoped Values lässt sich leichter begründen als die von Thread-Local-Variablen. Sie haben auch geringere Speicher- und Zeitkosten, insbesondere wenn sie zusammen mit virtuellen Threads (JEP 444) und strukturierter Nebenläufigkeit (JEP 480) verwendet werden.
ZGC: Standardmäßiger generationsbasierter Modus
JEP 474 – schaltet den Standardmodus des Z Garbage Collectors (ZGC) auf den generationsbasierten Modus um. Rückmeldungen aus der Nutzung des in JDK 21 eingeführten generationsbasierten ZGC sowie interne Tests haben bestätigt, dass dieser in den meisten Anwendungsfällen deutlich besser funktioniert als der nicht-generationsbasierte ZGC. Dieser JEP verwirft außerdem den nicht-generationsbasierten Modus von ZGC mit dem Ziel, ihn in einer zukünftigen JDK-Version zu entfernen.
Markdown für Dokumentationskommentare
JEP 467 – ermöglicht die Verwendung von Markdown anstelle der bisherigen Kombination aus HTML und Javadoc-@-Tags zum Schreiben von Kommentaren in der Javadoc-Dokumentation. Das neue Format erleichtert das Lesen und Verstehen der Dokumentation in Quellform.
Vorschlag zur Entfernung der Speicherzugriffsmethoden in sun.misc.unsafe
JEP 471 – Mit der Einführung der Foreign Function & Memory API (JEP 454) in JDK 22 wurde eine unterstützte API für den effizienten Zugriff auf externen (fremden) Speicher bereitgestellt. Daher wurde die zukünftige Entfernung der Methoden in sun.misc.unsafe angekündigt, die für den fremden Speicherzugriff verwendet werden.
Hier findest du die Release Notes zu Java JDK 23.
Fazit
Java 23 bringt eine Vielzahl von Verbesserungen, die die Arbeit der Entwickler vereinfachen und eine effizientere Nutzung der Plattform ermöglichen. Neue Funktionen, wie Sprach-, Leistungs- und Tool-Verbesserungen, bestätigen erneut, dass Java für viele Entwickler die bevorzugte Wahl ist.
Java SE 21 (LTS)
Die Veröffentlichung der neuen Version von Java JDK steht kurz bevor, und wir haben uns in unserem Blog entschieden, die neuen Sprachfunktionen genauer unter die Lupe zu nehmen. Der geplante Veröffentlichungstermin ist der 19. September 2023. Es ist jedoch bereits möglich, diese Version im Early Access herunterzuladen und mit ersten Experimenten zu beginnen.
Java 21 (nach Java 17) ist erneut eine Langzeit-Support-Version (LTS), was bedeutet, dass Oracle kostenlose Updates mindestens fünf Jahre lang, also bis September 2028, und erweiterten, kostenpflichtigen Support bis September 2031 bereitstellen wird.
Java 21 Features, Änderungen und Verbesserungen
Virtuelle Threads (virtual threads)
Virtuelle Threads sind leichtgewichtige Threads, die das Schreiben, Warten und Überwachen von hochperformanten, nebenläufigen Anwendungen erheblich vereinfachen. Sie ermöglichen das Skalieren von Serveranwendungen nach dem Thread-per-Request-Prinzip bei effizienter Hardwareauslastung, die einfache Migration bestehenden Codes, der das API lang.Thread verwendet, auf virtuelle Threads mit minimalen Änderungen sowie einfaches Debugging und Profiling virtueller Threads mit den vorhandenen JDK-Tools.
Virtuelle Threads wurden in JDK 19 und JDK 20 eingeführt und werden in JDK 21 fertiggestellt. Mit JDK 21 unterstützen virtuelle Threads nun Thread-lokale Variablen während der gesamten Laufzeit, und es ist nicht erlaubt, virtuelle Threads ohne diese Variablen zu erstellen. Die garantierte Unterstützung von Thread-lokalen Variablen stellt sicher, dass viele bestehende Bibliotheken ohne Änderungen mit virtuellen Threads verwendet werden können.
Sequenzielle Kollektionen (sequenced collections)
Sequenzielle oder geordnete Kollektionen sind eine weitere interessante Neuerung. JDK 21 führt ein Design für geordnete Kollektionen ein und definiert Schnittstellen für Kollektionen mit einer festgelegten Reihenfolge. Jede Kollektion hat ein klar definiertes erstes, zweites und letztes Element. Es werden einheitliche APIs bereitgestellt, um das erste und letzte Element zu erhalten und Elemente in umgekehrter Reihenfolge zu verarbeiten. Die Motivation für diesen Entwurf liegt darin, dass das Java Collection Framework bisher keinen Typ hatte, der eine geordnete Sequenz von Elementen repräsentiert. Es fehlte eine einheitliche Menge an Operationen für solche Kollektionen. Diese Lücken führten zu Problemen und Beschwerden. Der Vorschlag definiert Schnittstellen für Sequenzen von Kollektionen, Mengen und Maps und integriert sie in die bestehende Hierarchie. Alle neuen Methoden haben Standardimplementierungen.
Datensatzmuster (record patterns)
Record Patterns ermöglichen die Dekonstruktion von Record-Werten. Muster und Typmuster können verschachtelt werden, was eine deklarative und kombinierbare Datenabfrage ermöglicht. Ziel ist es, das Pattern Matching auf die Destruktion von Record-Instanzen zu erweitern und verschachtelte Muster hinzuzufügen, um die Komposition von Datenabfragen zu ermöglichen. Diese Funktion wurde parallel zur Pattern-Matching-Funktion für Switch-Ausdrücke entwickelt.
Pattern Matching für Switch
Diese Funktion ermöglicht es dem Switch-Ausdruck bzw. der Switch-Anweisung, mehrere Muster zu testen, von denen jedes eine bestimmte Aktion ausführt. Dadurch wird eine sichere und prägnante Darstellung komplexer Datenabfragen ermöglicht. Diese Funktion wurde ursprünglich in JDK 17 entworfen, in späteren Versionen weiterentwickelt und soll in JDK 21 basierend auf dem Feedback und den Erfahrungen von Java-Entwicklern abgeschlossen und angepasst werden. Die wichtigsten Änderungen gegenüber früheren JEP-Versionen umfassen das Entfernen von Klammern in Mustern, die Zulassung qualifizierter Enumerationskonstanten sowie die Erhöhung der Sicherheit von Switch-Ausdrücken und -Anweisungen, indem sichergestellt wird, dass alle möglichen Eingabewerte abgedeckt sind. Ein weiteres Ziel ist es sicherzustellen, dass bestehende Switch-Schreibweisen weiterhin ohne Änderungen funktionieren und mit derselben Semantik ausgeführt werden.
Zeichenkettenvorlagen (string templates)
Diese Funktion liegt in JDK 21 als Vorschau vor und ergänzt bestehende String-Literale und Textblöcke in Java, indem sie Text mit eingebetteten Ausdrücken und Prozessoren kombiniert, um spezialisierte Ergebnisse zu erzeugen. Dieses Sprachfeature und die zugehörige API sollen das Schreiben von Java-Programmen vereinfachen, indem sie es ermöglichen, Zeichenketten mit zur Laufzeit berechneten Werten einfach auszudrücken. Es verspricht eine bessere Lesbarkeit von Ausdrücken, erhöhte Programmsicherheit, die Beibehaltung von Flexibilität und eine vereinfachte Nutzung von APIs, die Zeichenketten in anderen Sprachen als Java erwarten. Die Funktion ermöglicht zudem die Entwicklung von Nicht-String-Ausdrücken, die durch die Kombination von Textliteralen und eingebetteten Ausdrücken entstehen.
Unbenannte Muster und Variablen (unnamed patterns and variables)
Diese Funktion verbessert die Lesbarkeit und Wartbarkeit von Code, indem sie erlaubt, Muster ohne Angabe eines Namens oder Typs eines Komponentenfeldes zu erstellen. Unbenannte Variablen können initialisiert, aber nicht verwendet werden. Ziel ist es, unnötig verschachtelte Muster zu eliminieren und ungenutzte Variablen eindeutig zu kennzeichnen.
Unbenannte Klassen und Instanz-Main-Methoden (unnamed classes and instance main methods)
Diese Funktion zielt darauf ab, das Schreiben der ersten Java-Programme zu vereinfachen, sodass Lernende nicht sofort die komplexeren Sprachkonstrukte verstehen müssen, die für größere Projekte gedacht sind. Sie erlaubt die Erstellung einfacher Programme, die nach und nach um fortgeschrittene Funktionen erweitert werden können.
Strukturierte Nebenläufigkeit (structured concurrency)
Strukturierte Nebenläufigkeit vereinfacht die Programmierung in einem nebenläufigen Umfeld durch eine API, die Gruppen verwandter Aufgaben als Arbeitseinheiten verwaltet. Dadurch wird die Fehlerbehandlung verbessert, was Zuverlässigkeit und Beobachtbarkeit erhöht. Diese Funktion, die zuvor in JDK 19 und JDK 20 getestet wurde, wird nun als Vorschau-API im Paket util.concurrent bereitgestellt.
Scoped values
Die Vorschauversion dieser Funktion ermöglicht das Teilen unveränderlicher Daten zwischen Threads und Komponenten. Scoped Values werden Thread-lokalen Variablen vorgezogen, insbesondere bei der Verwendung einer großen Anzahl virtueller Threads. Diese Funktion verbessert die Lesbarkeit und Robustheit des Codes.
Prepare to disallow the dynamic loading of agents
Das Verbot des dynamischen Ladens von Agenten – diese Änderung zielt darauf ab, die Integrität der JVM zu verbessern, indem das Laden von Agenten zur Laufzeit einer Anwendung hervorgehoben und kontrolliert wird. Ziel ist es, das Gleichgewicht zwischen Wartungsänderungen und Codeintegrität zu verbessern und sicherzustellen, dass die meisten Tools von dieser Änderung nicht betroffen sind.
API zur Schlüsselkapselung (key encapsulation mechanism)
Diese Funktion ermöglicht die Nutzung von Algorithmen zur Absicherung symmetrischer Schlüssel unter Verwendung öffentlicher Kryptographie. Ziel ist es, Anwendungen zu ermöglichen, Algorithmen wie den RSA Key Encapsulation Mechanism (RSA-KEM) und das Elliptic Curve Integrated Encryption Scheme (ECIES) in verschiedenen Protokollen und kryptografischen Schemata zu verwenden.
Generation ZGC
Diese Funktion zielt darauf ab, die Leistung von Anwendungen durch die Trennung von Generationen für junge und alte Objekte zu verbessern. Generational ZGC ermöglicht eine effizientere Sammlung junger Objekte und führt zu einem geringeren Speicherverbrauch sowie zu einer niedrigeren Belastung durch die Garbage Collection (Sammlung nicht mehr benötigter, allokierter Speicherbereiche).
Foreign function & memory API
Ermöglicht die Interoperabilität von Java-Programmen mit Code und Daten außerhalb der Java-Laufzeitumgebung. Es erlaubt das Aufrufen externer Bibliotheken und den sicheren Zugriff auf Speicher, wodurch das JNI (Java Native Interface) ersetzt wird.
Vector-API (vector API)
Diese API ermöglicht die Durchführung von Berechnungen in Vektorform, was zu einer besseren Leistung im Vergleich zu skalaren Berechnungen führt. Das Ziel ist es, eine einfache und zuverlässige Lösung für Vektorberechnungen auf unterstützten Architekturen bereitzustellen.
Deprecate the Windows 32-bit x86 port for removal
Diese Änderung konzentriert sich darauf, den 32-Bit-Port für Windows x86 in einer zukünftigen Version zu entfernen. Windows 10, das letzte Betriebssystem von Microsoft mit Unterstützung für den 32-Bit-Modus, erreicht sein Lebenszyklusende im Oktober 2025.
Neben diesen Funktionen wird in JDK 21 auch eine Änderung bei der Zuordnung von Netzwerkschnittstellennamen unter Windows vorbereitet. Außerdem ist eine experimentelle Funktion namens „compact object headers“ geplant, die die Größe der Objekt-Header in der JVM verringern und somit den Speicherbedarf reduzieren soll.
Wenn dich die neuen Funktionen von Java JDK 21 interessieren und du mehr darüber erfahren möchtest, empfehlen wir dir, die offizielle Website von OpenJDK zu besuchen.
Java SE 20
Oracle hat am 21. März 2023 die Verfügbarkeit der neuesten Version der weltweit beliebtesten Programmiersprache und Entwicklungsplattform angekündigt. In diesem Artikel konzentrieren wir uns auf einige der bedeutendsten Neuerungen.
Java SE 20 (Oracle JDK 20) bringt Tausende von Verbesserungen in den Bereichen Leistung, Stabilität und Sicherheit, einschließlich Plattformverbesserungen, die Entwicklern helfen, ihre Produktivität zu steigern und Innovation sowie Wachstum in ihren Organisationen zu fördern. Seit über 25 Jahren ermöglicht Java Entwicklern, neue Generationen robuster, skalierbarer und sicherer Anwendungen zu entwerfen und zu erstellen.
Oracle JDK 20 ist keine Langzeit-Support-Version (LTS – long-term support), daher erhält es Updates nur so lange, bis es in sechs Monaten durch JDK 21 ersetzt wird.
Die letzte LTS-Version von Java bleibt somit weiterhin Oracle JDK 17 (veröffentlicht am 14. September 2021). Oracle hat jedoch Pläne angekündigt, den Zeitraum zwischen den LTS-Veröffentlichungen von drei Jahren auf zwei Jahre zu verkürzen, sodass JDK 21 als nächstes LTS im September 2023 geplant ist.
Die Anzahl der Änderungen in den JDK-Versionen hat sich im Laufe der Zeit kaum verändert, aber durch den sechsmonatigen Veröffentlichungsrhythmus hat sich die Geschwindigkeit, mit der neue Funktionen und produktionsreife Verbesserungen bereitgestellt werden, erheblich erhöht. Anstatt zehntausende Korrekturen vorzunehmen und fast hundert JEPs (JDK Enhancement Proposals) alle paar Jahre mit großen Releases zu liefern, werden Verbesserungen nun in kleineren Versionen auf einem vorhersehbareren sechsmonatigen Zeitplan veröffentlicht. Die Änderungen reichen von bedeutenden neuen Funktionen über kleinere Verbesserungen bis hin zu Routinewartung, Fehlerbehebungen und Dokumentationsoptimierungen. Jede Änderung wird durch einen separaten Commit und ein Issue im JDK-Bug-System repräsentiert.
Neuerungen in Java 20 JDK
Java 20 JDK enthält sieben JEPs (JDK Enhancement Proposals), die darauf abzielen, die Produktivität der Entwickler zu steigern, die Sprache Java zu verbessern und die Leistung, Stabilität und Sicherheit der Plattform zu erhöhen. Diese Funktionen umfassen virtuelle Threads, den Entwurf der Vector-API, strukturierte Nebenläufigkeit, Scoped Values, die Foreign Function and Memory API, Record Patterns und Pattern Matching für Switch-Anweisungen und -Ausdrücke.
Virtuelle Threads (virtual threads)
Virtuelle Threads sind leichtgewichtige Threads, die den Aufwand beim Schreiben, Warten und Debuggen von leistungsstarken, nebenläufigen Anwendungen reduzieren. Sie sind Instanzen der Klasse java.lang.Thread, aber sie sind nicht an ein bestimmtes Betriebssystem-Thread gebunden. Wenn Code, der in einem virtuellen Thread läuft, eine blockierende Ein-/Ausgabeoperation aufruft, suspendiert die Java Runtime den virtuellen Thread, bis er fortgesetzt werden kann. Das Betriebssystem-Thread, das mit dem suspendierten virtuellen Thread verbunden war, ist dann frei, andere virtuelle Threads auszuführen.
Virtuelle Threads eignen sich für Aufgaben, die den größten Teil der Zeit blockierend verbringen, häufig beim Warten auf den Abschluss von Ein-/Ausgabeoperationen. Sie sind jedoch nicht für langfristige, CPU-intensive Operationen gedacht.
Entwurf der Vector-API (vector API proposal)
Die Vector-API ist eine neue Funktion in Java 20 JDK, die eine API zur Darstellung von Vektorberechnungen einführt, die zuverlässig in optimale Vektorinstruktionen auf unterstützten CPU-Architekturen kompiliert werden, um eine Leistung zu erzielen, die über der von gleichwertigen skalaren Berechnungen liegt.
Das Ziel ist es, eine klare und prägnante API bereitzustellen, die in der Lage ist, eine breite Palette von Vektorberechnungen auszudrücken, bestehend aus Sequenzen von Vektoroperationen in Schleifen, eventuell mit Kontrollfluss. Es sollte möglich sein, Berechnungen zu formulieren, die in Bezug auf die Vektorgröße oder die Anzahl der Bahnen pro Vektor generisch sind, wodurch die Portabilität solcher Berechnungen über verschiedene Hardwareplattformen mit unterschiedlichen Vektorgrößen ermöglicht wird.
Strukturierte Nebenläufigkeit (structured concurrency)
Dies ist eine neue Funktion in Java SE 20 JDK, die eine API bereitstellt, um die Programmierung von Multithread-Anwendungen zu vereinfachen und mehrere Aufgaben, die in verschiedenen Threads ausgeführt werden, als eine Einheit der Arbeit zu behandeln. Fehlerbehandlung und Thread-Abbruch werden vereinfacht, was die Zuverlässigkeit verbessert und die Beobachtbarkeit erhöht.
Die einzige Änderung gegenüber dem Konzept in JDK 19 besteht darin, dass die Klasse StructuredTaskScope aktualisiert wurde, um die Vererbung von Scoped Values durch Threads zu unterstützen, die innerhalb des Task-Scopes erstellt wurden.
Scoped values
Scoped Values sind eine Neuerung in Java 20 JDK, die es Entwicklern ermöglicht, unveränderliche Daten innerhalb und zwischen Threads zu speichern und zu teilen. Diese neue API wird in Java 20 JDK als Inkubationsfunktion gemäß JEP 439 eingeführt.
In Java 20 JDK wird die neue Klasse jdk.incubator.concurrent.ScopedValue <T> eingeführt, die einen begrenzten Wert als Schlüssel-Wert-Paar darstellt. Grundsätzlich ist ein begrenzter Wert ein Wert, der nur einmal gesetzt wird und für eine begrenzte Zeit in einem Thread zum Lesen verfügbar ist. Begrenzte Werte ermöglichen die gemeinsame Nutzung von Daten, ohne Methodenargumente zu verwenden.
API für fremde Funktionen und Speicher (foreign function and memory API)
Diese neue Funktion in Java 20 JDK ermöglicht es Java-Programmen, mit Code und Daten außerhalb der Java Runtime zu interagieren. Durch effizientes Aufrufen fremder Funktionen (Code außerhalb der Java Virtual Machine [JVM]) und sicheren Zugriff auf fremden Speicher (nicht von der JVM verwalteter Speicher) können Java-Programme native Bibliotheken aufrufen und native Daten verarbeiten, ohne das Java Native Interface verwenden zu müssen. Das erhöht Benutzerfreundlichkeit, Leistung und Sicherheit.
Muster von Aufzeichnungen (record patterns)
Diese Verbesserung erweitert die Java-Sprache, indem sie es ermöglicht, Record-Patterns und Typ-Patterns zu verschachteln, um eine starke, deklarative und zusammensetzbare Form der Daten-Navigation und -Verarbeitung zu schaffen. Das hilft, die Produktivität der Entwickler zu steigern, indem es ihnen erlaubt, Pattern Matching für komplexere Datenabfragen zu nutzen.
Mustervergleich für Switch-Anweisungen und -Ausdrücke (pattern matching for switch statements and expressions)
Ermöglicht Entwicklern, Patterns in Switch-Bedingungen zu verwenden. Im Vergleich zur Verwendung von Konstanten bietet dies größere Flexibilität und Ausdrucksstärke.
Fazit
Die neue Version Java SE 20 JDK bringt neben Fehlerbehebungen auch sieben JEPs zur Verbesserung der Produktivität der Entwickler, zur Weiterentwicklung der Sprache Java und zur Steigerung der Leistung, Stabilität und Sicherheit der Plattform.
Du kannst sie hier herunterladen: Java SE 20 JDK Download.
Java SE 17 (LTS)
Bis März 2022 ist die neueste Version Java 17, die eine neue Rendering-Pipeline für macOS-Systeme, die Unterstützung für den neuesten Apple M1-Chip und die Unterstützung für sealed classes eingeführt hat. Außerdem gibt es sprachliche Verbesserungen sowie die Entfernung der Komplexität von ahead-of-time und just-in-time.
Quelle: Java SE 17
Java SE 16
Version 16 wurde im März 2021 veröffentlicht und brachte eine bedeutende Änderung mit sich – die Migration von OpenJDK zu Git. Der Quellcode von OpenJDK wurde von Mercurial zu Git migriert. Der Grund dafür war die Größe der Metadatendateien, bessere Werkzeuge und das Hosting.
Quelle: Java SE 16
Java SE 15
Java SE 15 wurde im September 2020 veröffentlicht und brachte drei große Aktualisierungen mit sich:
Textblöcke als Standard
Textblöcke, die in Java 13 als Vorschau eingeführt wurden, sind nun ein Sprachstandard geworden.
Sealed-Klassen
Die Zugriffsmodifikatoren public, protected und private bieten nur eine sehr grobe Kontrolle. Mit den Schlüsselwörtern sealed, non-sealed und permits kann der Programmierer die Vererbungshierarchie gezielt steuern. Ziel der sealed Klassen ist es, einzelnen Klassen zu ermöglichen zu deklarieren, welche Typen als Subtypen verwendet werden dürfen. Dies gilt auch für Schnittstellen und die Festlegung, welche Typen sie implementieren dürfen.
In diesem Beispiel haben wir eine abstrakte Klasse namens Person deklariert. Gleichzeitig haben wir angegeben, dass nur die Klassen Employee und Manager sie erweitern dürfen. Die Erweiterung einer sealed-Klasse erfolgt wie bisher in Java mit dem Schlüsselwort extends:
Jede Klasse, die eine sealed-Klasse erweitert, muss selbst als sealed, non-sealed oder final deklariert werden. Das stellt sicher, dass die Klassenhierarchie abgeschlossen bleibt und der Compiler sie vollständig kennt.
Verborgene Klassen
Das Ziel der verborgenen Klassen ist es, Klassen zu erstellen, die nicht sichtbar sind. Das bedeutet, dass sie nicht von anderen Klassen verknüpft oder durch Reflexion entdeckt werden können. Solche Klassen haben in der Regel einen kurzen Lebenszyklus, daher sind sie in erster Linie auf Effizienz ausgelegt. Sie sind besonders nützlich für Entwickler, die mit der JVM arbeiten.
Quelle: Java SE 15
Java SE 14
Im März 2020 wurde Java SE 14 veröffentlicht und brachte vier bedeutende Verbesserungen:
Switch als Standard
Der switch-Ausdruck, der in Java 12 als Vorschau eingeführt und in Version 13 verbessert wurde, ist nun ein Sprachstandard geworden.
Verbesserung der NullPointerException
Die NullPointerException hatte in der Vergangenheit keinen besonders hohen Informationswert. Der Grund war, dass man nur erkennen konnte, dass ein bestimmter Wert in einer Datei null war. In der neuen Version ist jedoch alles anders. Die Funktion wurde erweitert, und Programmierer erfahren nun endlich, welche Variable diese Ausnahme verursacht hat.
Java Records
Records wurden eingeführt, um wiederkehrenden Standardcode in POJO-Datenmodellen zu reduzieren. Sie vereinfachen die tägliche Entwicklung, erhöhen die Effizienz und minimieren das Risiko menschlicher Fehler erheblich. Zum Beispiel kann ein Datenmodell für einen Benutzer mit ID und Passwort einfach wie folgt definiert werden:
In diesem Fall wurde auch das neue Schlüsselwort record verwendet, das automatisch Konstruktor-, Getter-, equals-, hashCode- und toString-Methoden hinzufügt.
Pattern Matching für instanceof
Version 14 führte das Mustervergleichs-Feature ein, um den Code zu vereinfachen. Ohne die neue Funktion würde der Code so aussehen:
Dank der neuen Java-Version sieht der Code jedoch viel einfacher und kürzer aus:
Quelle: Java SE 14
Java SE 13
Java 13 wurde im September 2019 veröffentlicht. Das Update brachte zwei Hauptverbesserungen mit sich:
Textblöcke
Die neue Funktion der Textblöcke ermöglichte es Entwicklern, mehrzeilige Texte leichter zu lesen. Sie verwendet drei Anführungszeichen, ähnlich wie Python und Groovy.
Darüber hinaus stehen dir alle Funktionen der Klasse String zur Verfügung.
Verbesserungen des switch-Ausdrucks
Java 13 verbessert den switch-Ausdruck aus Version 12 mit dem Schlüsselwort yield. Mit yield können Werte aus einem switch-Ausdruck zurückgegeben werden.
Quelle: Java SE 13
Java SE 12
Version 12 wurde im März 2019 veröffentlicht und brachte nur eine wesentliche Verbesserung mit sich. Diese war die alternative Schreibweise des switch-Ausdrucks. Das folgende Beispiel vergleicht die alte und die neue Schreibweise des switch-Ausdrucks. Der Code unterscheidet zwischen Arbeits- und Wochenendtagen.
Der Code in der neuen Schreibweise sieht viel sauberer und kürzer aus. Die neue Form von switch entfernt außerdem die Notwendigkeit des Schlüsselworts break. Das bedeutet, dass der Code stoppt, sobald er das erste passende Ergebnis findet. Ein weiterer Unterschied ist, dass einer Variablen direkt ein Wert aus der switch-Anweisung zugewiesen werden kann.
Quelle: Java SE 12
Java SE 11 (LTS)
Java 11 war laut der jährlichen Umfrage des Unternehmens Snyk die am häufigsten verwendete Version im Jahr 2021. Sie wurde von bis zu 61,5 % der Befragten genutzt. Nur 12 % aktualisierten die Sprache auf die neueste Version, die zum Zeitpunkt der Umfrage Java 15 war.
Interessant waren auch die Antworten auf die Frage, warum die Menschen nicht auf eine neuere Version umgestiegen sind. Die Mehrheit war sich einig, dass sie nicht in der Lage oder nicht bereit ist, Java alle sechs Monate zu migrieren. Andere, etwa 51 %, gaben an, dass sie keine Änderungen benötigen, da ihre aktuelle Umgebung gut funktioniert.
Zu den weiteren Gründen, warum die Teilnehmer der Umfrage bei älteren Versionen bleiben, gehören:
- hohe Migrationskosten,
- mangelnde Bereitschaft der Kunden zur Migration,
- keine besonderen Verbesserungen in der neuen Version,
- Anwendungsserver oder Bibliotheken unterstützen die neuesten Versionen nicht.
Aus der Umfrage von 2020 ging außerdem hervor, dass die Strategie der meisten Entwickler (55 %) darin besteht, bei den langfristigen Versionen zu bleiben. Dennoch gaben bis zu 22 % der Befragten an, dass sie erst entscheiden wollen, ob sie ein Upgrade durchführen oder nicht. Sie möchten herausfinden, ob die neu eingeführten Funktionen wichtig genug sind, um eine Migration zu rechtfertigen.
Java SE 11 wurde sechs Monate nach Version 10 veröffentlicht, also im September 2018. Es brachte zwei wesentliche Änderungen:
Ausführen von Java-Dateien
Eine wichtige Änderung in dieser Version ist, dass der Programmierer die Java-Quellcodedateien nicht mehr explizit mit dem Befehl javac kompilieren muss.
Stattdessen kannst du die Datei direkt mit dem Befehl java ausführen.
Verwendung der Syntax lokaler Variablen
Java 11 unterstützt die Verwendung der Syntax lokaler Variablen in Lambda-Parametern. Diese Funktion kann verwendet werden, um Modifikatoren auf lokale Variablen anzuwenden, zum Beispiel zur Definition einer Annotation.
Quelle: Java SE 11
Java SE 10
Java SE 10 wurde im März 2018 von Oracle veröffentlicht. Für Entwickler brachte es zwei wichtige Änderungen:
OpenJDK
Um die Java-Community offener zu gestalten, begann Oracle damit, die OpenJDK-Binärdateien als primäres JDK der Zukunft zu bewerben. Das Problem ist jedoch, dass du für erweiterte Unterstützung älterer Java-Versionen bezahlen musst.
Variable var
Die Variable var ist nichts Neues, da sie auch in anderen Programmiersprachen existiert. Ihr Hauptvorteil ist, dass sie die Ausdrucksstärke der Sprache verringert. In der Praxis bedeutet das, dass du mit ihr lange Objektnamen oder das doppelte Schreiben desselben Namens vermeiden kannst.
Programmierer könnten sich jedoch fragen, was der Unterschied zwischen var und Object ist. Das Schlüsselwort var bedeutet, dass der Compiler den Typ automatisch erkennen soll. Mit Object hingegen castest du deine Objektinstanz auf den Typ Object. Das bedeutet, dass du zwar allgemeine Methoden der Klasse Object verwenden kannst, aber nicht mehr deine klassenspezifischen Methoden. Dadurch entsteht ein Kompilierungsfehler.
Quelle: Java SE 10
Java SE 9
Java SE 9 wurde im September 2017 veröffentlicht und brachte mehrere Änderungen mit sich. Nicht alle waren jedoch bedeutend oder wichtig. Hier sind die drei wichtigsten:
Modularität – Jigsaw Project
Die bedeutendste Änderung in Java 9 war das Modulsystem, das als Jigsaw Project bezeichnet wurde. Ein Modul ist eine Gruppe von Code mit bestimmten Eigenschaften. Die Modulfunktion teilt die Programmiersprache in kleinere Module, um Folgendes zu bieten:
- Abschottung,
- Reduzierung von Versionskonflikten,
- Hinzufügen von Kapselung,
- höhere Sicherheit,
- bessere Leistung,
- angepasste JDK-Laufzeit mit kleinerer Größe.
Um ein neues Modul zu erstellen, benötigst du die Datei module-info.java in deinem src.main.java-Verzeichnis. Darin kannst du deine Modulanforderungen definieren.
Private Methoden in Java-Schnittstellen
Eine weitere Funktion von Java 9 ermöglicht es, private und statische Methoden in Schnittstellen zu schreiben, um überflüssigen Code zu vermeiden.
Java-Kommandozeilenwerkzeug JShell
Oracle hat ein neues REPL-Tool namens JShell entwickelt. REPL steht für Read – Evaluate – Print – Loop. Wie der Name schon sagt, dient es dazu, Befehle auszuführen, Variablen, Klassen und Methoden zu erstellen und sie schnell zu testen. Es ist großartig zum Testen kleiner Codeausschnitte, die sonst die Erstellung einer neuen Klasse mit einer main-Methode erfordern würden.
JShell befindet sich im Verzeichnis <JAVA_HOME>/bin, und du kannst es starten, indem du im Kommandozeilenfenster jshell eingibst und sofort mit dem Schreiben von Code beginnst.
Die interaktive Java-JShell wird mit einer Verlaufshistorie und automatischer Vervollständigung geliefert. Sie bietet außerdem Funktionen wie das Speichern und Laden aus Dateien sowie einzelner oder mehrerer Codezeilen:
Quelle: Java SE 9
