Java JDK: Versionsübersicht, Unterschiede zwischen LTS, SE, JRE und Java 24

Von  Jozef Wagner

Java • 41 min. Epub lesen • 29. 9. 2025

Von  Jozef Wagner •

Java • 41 min. Epub lesen • 29. 9. 2025

Wir geben Ihnen einen Überblick über die Java-Versionen, einen Vergleich der Java JDK-, SE- und LTS-Versionen und eine Zusammenfassung der wichtigsten Änderungen in den neuesten Versionen – einschließlich Java 24, das die Grenzen der Sprache noch einmal einen Schritt weiter verschiebt. Sie erhalten ein klares Bild davon, worin die Hauptunterschiede zwischen den Versionen bestehen, was die neuen Funktionen bringen und worauf Sie bei der Migration achten müssen.

Java-Versionen von JDK, SE, LTS und Häufigkeit der Veröffentlichungen

Java wird seit mehr als zwei Jahrzehnten kontinuierlich weiterentwickelt. Um mit den modernen Entwicklungsanforderungen Schritt halten zu können, wurde es auf ein halbjährliches Veröffentlichungsmodell umgestellt. Die erste agile Version war Java SE 9, die im September 2017 veröffentlicht wurde. Die Version Java 10 erschien dann sechs Monate später. Alle sechs Monate wird eine neue Version des Java JDK veröffentlicht, die Verbesserungen, Korrekturen und experimentelle Funktionen enthält.

Für Unternehmen und Entwickler ist es wichtig, den Unterschied zwischen LTS-Releases (Long-Term Support), die für Stabilität und langfristigen Support sorgen, und Non-LTS-Releases zu verstehen, die eher dazu dienen, neue Funktionen zu testen und zukünftige LTS-Releases vorzubereiten.

Java JDK (Java-Entwicklungskit)

Java JDK (Java Development Kit) ist das offizielle Toolkit für die Entwicklung von Anwendungen in Java. Es enthält einen Compiler javac, der den Quellcode in Bytecode übersetzt, der auf der Java Virtual Machine (JVM) ausführbar ist, einen Debugger, Standard-API-Bibliotheken, Dokumentation und verschiedene Tools zum Verwalten und Testen von Anwendungen. Das JDK ist also für jeden Entwickler unverzichtbar, denn es bietet eine vollständige Umgebung zum Schreiben, Kompilieren, Ausführen und Debuggen von Code.

Zusätzlich zu den grundlegenden Werkzeugen bietet das JDK verschiedene Hilfsprogramme, wie z.B. javadoc zur Generierung von Dokumentation direkt aus dem Quellcode oder jlink zur Erstellung von benutzerdefinierten Java-Laufzeit-Images. Es ist wichtig, es von der Java-Laufzeitumgebung (JRE) zu unterscheiden, die nur zum Ausführen fertiger Anwendungen verwendet wird. Während die JRE von Endbenutzern verwendet wird, ist das JDK in erster Linie für Entwickler gedacht – ohne es könnten keine Java-Anwendungen erstellt oder getestet werden.

Java SE(Java-Plattform, Standard Edition)

Java SE (Java Platform, Standard Edition) ist die Basisversion der Java-Plattform, die die standardisierten APIs, die Syntax und das Verhalten der Sprache definiert. Sie enthält wichtige Bibliotheken und Pakete wie Collections, Parallelität, I/O, Netzwerke, Sicherheit und XML-Verarbeitung. Mit Java SE gibt es eine gemeinsame Grundlage, auf der alle Java-Anwendungen und -Frameworks – von einfachen Desktop-Programmen bis hin zu groß angelegten Unternehmenslösungen – aufgebaut sind.

Java SE ist kein Entwicklungswerkzeug wie das JDK, sondern vielmehr ein „Standard“ und eine Spezifikation dessen, was jede Version von Java enthalten sollte. Es ist die offizielle Sprachdefinition, der alle Java-Implementierungen (z.B. OpenJDK) folgen müssen. Für Entwickler bietet er die Sicherheit, dass Code, der mit Java SE geschrieben wurde, in jeder Umgebung funktioniert, die mit diesem Standard kompatibel ist.

JRE (Java-Laufzeitumgebung)

Die Java-Laufzeitumgebung (JRE) ist eine Umgebung, die für die Ausführung von in Java geschriebenen Anwendungen entwickelt wurde. Sie enthält die Java Virtual Machine (JVM), die für die Übersetzung und Ausführung des Bytecodes zuständig ist, sowie die Kernbibliotheken, die für die Ausführung der Programme benötigt werden. Im Gegensatz zum JDK stellt sie keine Entwicklungstools zur Verfügung – ihre Aufgabe besteht lediglich darin, sicherzustellen, dass die fertige Anwendung auf einem Computer oder Server ausgeführt werden kann.

Daher eignet sich JRE für Endbenutzer oder Produktionsumgebungen, in denen Anwendungen nur ausgeführt, aber nicht weiter entwickelt werden. Ein Entwickler kommt in der Regel mit einem JDK aus (das die JRE automatisch enthält), während eine eigenständige JRE von denjenigen verwendet wird, die die Anwendungen nur ausführen.

Java LTS (Langfristige Unterstützung)

Java LTS (Long-Term Support) steht für Java-Versionen mit garantiertem Langzeit-Support von Oracle oder anderen Anbietern (Adoptium, Red Hat, etc.). Jede LTS-Version erscheint etwa alle drei Jahre und bietet Unternehmen Stabilität, Sicherheitspatches und Fehlerbehebungen für 8 Jahre oder länger. Aus diesem Grund sind LTS-Versionen die häufigste Wahl für Unternehmensprojekte, bei denen Zuverlässigkeit und minimales Betriebsrisiko im Vordergrund stehen.

Im Gegensatz zu Nicht-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 zur nächsten (z.B. von Java 11 zu 17 oder 21) und vermeiden so die Probleme, die mit kurzfristigen Versionen verbunden sind. LTS bietet somit eine sichere Grundlage für langfristige Projekte und Produktionsumgebungen.

Unterschiede zwischen Java JDK, SE, LTS, JRE

LTS-Versionen sind die erste Wahl für Stabilität und langfristigen Support. Unternehmen setzen sie in der Produktion ein, weil sie mehrere Jahre lang Sicherheits-Patches und Korrekturen erhalten.

Im Gegensatz dazu sind Nicht-LTS-Versionen kurzlebig – sie kommen alle sechs Monate heraus und bringen schnellere Innovationen. Entwickler verwenden sie, um neue Funktionen zu testen, aber in der Produktion werden sie normalerweise auf die nächste LTS-Version migriert.

Das Java Development Kit (JDK ) ist ein Paket von Tools, das Sie mit jeder Version von Java erhalten und das von Entwicklern direkt verwendet wird.
Java SE (Standard Edition) definiert den zentralen Sprachstandard und die API, auf denen das gesamte Ökosystem aufbaut.

• LTS-Versionen → Stabilität, langfristige Unterstützung, geeignet für die Produktion
• Nicht-LTS-Versionen → kurzfristig, Einführung neuer Funktionen, geeignet für Tests
• JDK (Java Development Kit) → Entwicklerwerkzeuge (Compiler, Debugger, Bibliotheken)
• Java SE (Standard Edition) → der Kernstandard und die API, auf der ganz Java basiert

Wenn Sie also entscheiden, welche Version Sie wählen sollen:

• Für ein langfristiges Projekt sollten Sie sich für LTS entscheiden.
• Für Experimente und die schnelle Einführung neuer Funktionen ist Non-LTS geeignet.

Migration zwischen Java JDK-Versionen

Bei der Migration auf eine neue Java-Version geht es nicht nur um das Herunterladen des neuesten JDK. Es ist ein Prozess, der Planung, Tests und die Anpassung des vorhandenen Codes erfordert.

Die wichtigsten Schritte der Migration:

1. Projekt-Analyse
   • Prüfen Sie, welche Bibliotheken und Frameworks Sie verwenden.
   • Prüfen Sie, ob sie mit der Zielversion von Java kompatibel sind.
2. Prüfen Sie auf entfernte und veraltete APIs
   • Bei neuen Versionen werden einige Funktionen als veraltet markiert und später ganz entfernt.
   • Typische Beispiele: alte Sicherheitsalgorithmen, interne sun.* APIs.
3. Kompatibilitätstests
   • Führen Sie vorhandene Tests mit der neuen JDK-Version durch.
   • Achten Sie auf Warnungen und Kompilierungsfehler.
4. Modifizierung der Build- und CI/CD-Pipeline
   • Aktualisieren Sie die Build-Tools (Maven, Gradle).
   • Stellen Sie sicher, dass die CI/CD-Pipeline mit der richtigen JDK-Version läuft.
5. Allmählicher Übergang
   • Bei großen Projekten ist es ratsam, von LTS zu LTS zu wechseln (z.B. von 11 → 17 → 21).
   • Dadurch werden Probleme zwischen den Versionen vermieden und Sie bleiben stabil.
6. Leistungs- und Regressionstests
   • Testen Sie Ihre Anwendung unter Last, um eventuelle Verlangsamungen oder Speicherlecks zu erkennen.

Die häufigsten Probleme bei der Migration:

• Nicht unterstützte Bibliotheken – ältere Abhängigkeiten funktionieren möglicherweise nicht mit dem neuen JDK.
• Entfernte APIs – wenn das Projekt eine interne JDK-API verwendet, kann dies zu Fehlern führen.
• Sicherheitsänderungen – Strengere TLS/SSL-Einstellungen können ältere Verbindungen blockieren.

Es ist immer am sichersten, auf die neueste LTS-Version zu migrieren, die Anwendung zu testen und sie dann in der Produktion einzusetzen. Nicht-LTS-Versionen sind gut zum Experimentieren geeignet, aber nicht für langfristig laufende Anwendungen.ň

Als nächstes werden wir die Änderungen und Verbesserungen in jeder Java-Version im Detail besprechen.

Java SE 24

Java 24 brachte eine neue Version des JDK 24 mit symbolischen 24 Verbesserungen der Sprache, API, Plattformleistung, Stabilität und Sicherheit. Wir haben schon lange keine Version mehr gehabt, die so voll mit neuen Funktionen ist. Verschwenden wir also keine Zeit und stellen wir sie nacheinander vor.

Java JDK 24 bringt mehrere Änderungen und Verbesserungen

Die neue Version von Java 24 wurde von Oracle am 18. März 2025 herausgebracht. Das vollständige Java Development Kit 24 (JDK 24) für diese Version von Java bringt eine Reihe von Verbesserungen für Programmierer.

Wir empfehlen Ihnen…

Java 24, einschließlich der Versionshinweise, steht unter diesem Link zum Download bereit

Wie frühere Versionen von Java ist auch Java 24 das Ergebnis der kollektiven Bemühungen vieler Mitwirkender, sowohl von Einzelpersonen als auch von Organisationen in der OpenJDK-Community. Während die Anzahl der Änderungen in den JDK-Versionen seit mehreren Jahren in etwa gleich geblieben ist, hat sich das Tempo, mit dem neue Funktionen und Verbesserungen in die Produktion gelangen, im letzten sechsmonatigen Zyklus erheblich beschleunigt.

Die Änderungen in JDK 24 reichen von wichtigen neuen Funktionen über kleinere Verbesserungen bis hin zu routinemäßiger Wartung, Fehlerbehebungen und Verbesserungen der Dokumentation. Jede Änderung für ein bestimmtes Ticket wird durch einen separaten Commit im JDK Bug System Repository dargestellt.

JDK 24 führt 24 Verbesserungen ein, die wichtig genug sind, um eigene JDK – JEP Verbesserungsvorschläge zu erhalten, darunter 8 Feature-Demos und 1 Inkubator-Feature.

Oracle JDK 24 Sprachfunktionen

Primitive Typen in Patterns, instanceof, und switch (Beispiel 2)

JEP 488: Erweitert den Musterabgleich, um Typmuster mit primitiven Typen in allen Kontexten zuzulassen. Gleichzeitig werden die Operatoren instanceof und switch hinzugefügt, um alle primitiven Typen zu unterstützen, einschließlich sicherer Tests und Konvertierungen. Dadurch wird eine einheitliche, aussagekräftigere Sprache für die Verarbeitung von Werten und Typen erreicht, ohne dass manuelle Eingaben oder Bereichsüberprüfungen erforderlich sind.

Flexible Konstruktionskörper (Beispiel 3)

JEP 492: Erlaubt das Einfügen von allgemeinen Befehlen vor expliziten Aufrufen von super(…) oder this(…) im Körper des Konstruktors; diese Befehle können Felder initialisieren und Argumente validieren, dürfen aber kein noch unfertiges Objekt verwenden. Dies bietet ein natürlicheres Modell für die Validierung und Vorbereitung von Daten vor der Erstellung einer Superklasse und vereinfacht und verdeutlicht den Code von Konstruktoren.

Modul-Import-Deklarationen (Beispiel 2)

JEP 494: Führt ein neues Syntaxkonstrukt ein, import module M;, das alle öffentlichen Top-Level-Klassen und Schnittstellen, die von Modul M exportiert werden (einschließlich transitive Abhängigkeiten), über einen einzigen Befehl importiert. Dadurch entfällt die Notwendigkeit für viele import … .*-Befehle und vereinfacht die Wiederverwendung von Modulbibliotheken in allen Arten von Projekten erheblich.

Einfache Quelldateien und Instanz-Hauptmethoden (Beispiel 4)

JEP 495: Vereinfacht die Erstellung kleiner Java-Programme: Ermöglicht das Schreiben ausführbarer Programme ohne benutzerdefinierte Klassen und ohne Boilerplate public static void main(String[] args), unterstützt Instanz-Main-Methoden (ohne Parameter und Modifikatoren) und einfache Quelldateien mit automatischen Importen von grundlegenden Konsolen-E/A-Methoden und dem gesamten java.base-Modul. Dies reduziert die Lernkurve und ermöglicht gleichzeitig einen reibungslosen Übergang zu vollständigen Programmen.

Oracle JDK 24 Bibliotheken

Klassendatei-API

JEP 484: Einführung einer standardisierten API(java.lang.classfile) zum Parsen, Erzeugen und Umwandeln von .class-Dateien gemäß dem von der JVM-Spezifikation definierten Format. Das Ziel ist es, die internen ASM-Bibliotheken durch eine einheitliche, wartbare und vollständig spezifizierte Schnittstelle zu ersetzen.

Stream Gatherer

JEP 485: Erweitert die Stream API um die Möglichkeit, benutzerdefinierte Zwischenoperationen (Stream::gather) zu definieren, die benutzerdefinierte Transformationen von Stream-Elementen (eins-zu-eins, eins-zu-viele, viele-zu-viele) mit voller Parallelisierungsunterstützung und ohne die Notwendigkeit externer Datensammler ermöglichen. Dies vereinfacht die ausdrucksstarke und effiziente Verarbeitung von Datenpipelines.

Eingeschränkte Werte (Beispiel 4)

JEP 487: Führt einen neuen ScopedValue-Typ für die gemeinsame Nutzung unveränderlicher Daten innerhalb einer Methode, ihrer Aufrufe und neu erstellter Threads als einfachere und leistungsfähigere Alternative zu ThreadLocal ein. Er hat geringere Platz- und Zeitanforderungen und ist besonders nützlich bei der Verwendung von virtuellen Threads.

Vektor-API (9. Inkubator)

JEP 489: Führt eine plattformneutrale, hochleistungsfähige Schnittstelle zum Ausdrücken von Vektorberechnungen ein, die zur Laufzeit auf native SIMD-Anweisungen auf unterstützten CPUs abgebildet wird. Dadurch können Entwickler eine bessere Leistung erzielen als mit äquivalenten skalaren Berechnungen, die zunehmend in der KI eingesetzt werden.

Strukturierte Gleichzeitigkeit (Beispiel 4)

JEP 499: Ermöglicht die Verwaltung von Gruppen zusammenhängender Aufgaben als eine einzige Arbeitseinheit über eine neue API, die das Fehlermanagement, den Abbruch und die Beobachtbarkeit in konkurrierenden Anwendungen vereinfacht. Dieses Konzept hilft, „Thread Leaks“ zu verhindern und verbessert die Zuverlässigkeit und Lesbarkeit des Codes.

Oracle JDK 24 Sicherheits-Bibliotheken

Schlüsselableitungsfunktion API (Beispiel)

JEP 478: Einführung der neuen javax.crypto.KDF API für die Erzeugung und Verteilung von kryptographischen Schlüsseln mit Standard-KDF-Algorithmen wie HKDF (RFC 5869) und Argon2 (RFC 9106). Sie ermöglicht Anwendungen die einfache Ableitung mehrerer Schlüssel aus einem einzigen geheimen Eingabeschlüssel (z.B. bei Hybrid Public Key Encryption oder TLS 1.3) und bietet eine Schnittstelle für die Erweiterbarkeit auf andere KDF-Implementierungen.

Quantenresistenter Modul-Gitter-basierter Schlüssel-Kapselungs-Mechanismus

JEP 496: Liefert eine Implementierung von ML-KEM, einem quantenresistenten KEM-Schema, das in NIST FIPS 203 standardisiert ist. Erweitert KeyPairGenerator, KEM und KeyFactory um die Parametersätze ML-KEM-512, ML-KEM-768 und ML-KEM-1024 und ermöglicht Anwendungen den sicheren Austausch symmetrischer Schlüssel, die gegen Angriffe durch zukünftige Quantencomputer resistent sind.

Quantenresistenter Modul-Gitter-basierter digitaler Signatur-Algorithmus

JEP 497: Unterstützt ML-DSA, einen quantenresistenten Algorithmus für digitale Signaturen (FIPS 204). Implementiert KeyPairGenerator, Signature und KeyFactory für die drei Parametersätze ML-DSA-44, ML-DSA-65 und ML-DSA-87 und ermöglicht so die Authentifizierung und Überprüfung der Datenintegrität mit Widerstand gegen Quantenangriffe.

Oracle JDK 24 Werkzeuge

Verknüpfung von Laufzeitbildern ohne JMODs

JEP 493: Ermöglicht Ihnen die Erstellung von Laufzeit-Images ohne JMOD-Dateien über jlink, reduziert die Größe der JDK-Installation um bis zu 25% und erleichtert die Modulverwaltung in Cloud- und Container-Umgebungen.

Verbesserung der Oracle JDK 24-Laufzeitleistung

Compact Object Headers (experimentell)

JEP 450: Verringert die Größe von Java-Objekt-Headern von 96-128 Bit auf 64 Bit auf 64-Bit-Plattformen, was Speicher spart und die Datenlokalität im Cache verbessert. Aktiviert durch VM-Optionen:
-XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders.

Späte Barriereerweiterung für G1

JEP 475: Verschiebt die Erweiterung der Speicherbarrieren in der G1 GC von den frühen Phasen der C2-Kompilierung auf spätere Phasen, wodurch die Kompilierungszeit reduziert und die Implementierung vereinfacht wird, während die Leistung des generierten Codes erhalten bleibt.

Vorausschauendes Laden und Verknüpfen von Klassen

JEP 483: Verbessert den JVM-Start durch das Zwischenspeichern von geladenen und vorverknüpften Klassen während eines einzigen Starts, die HotSpot beim nächsten Start verwendet, wodurch die anfängliche Startzeit reduziert wird.

ZGC: Entfernen Sie den Nicht-Generationen-Modus

JEP 490: Entfernt den nicht-generationalen Modus für den Z Garbage Collector (-XX:+ZGenerational), wodurch die Komplexität des Codes reduziert und der generative ZGC primär wird, was für die meisten Einsätze besser geeignet ist.

Virtuelle Threads ohne Pinning synchronisieren

JEP 491: Verbessert die Skalierbarkeit von synchronisierten Blöcken bei der Verwendung von virtuellen Threads, indem der Plattform-Thread beim Blockieren nicht gehalten, sondern für andere Threads freigegeben wird, wodurch die Anzahl der bedienten virtuellen Threads erhöht wird.

Quellcode Oracle JDK 24

Generational Shenandoah (experimentell)

JEP 404: Führt einen experimentellen Generationsmodus für Shenandoah GC ein, der den anhaltenden Durchsatz, die Ausfallsicherheit bei plötzlichen Belastungen und die Speichernutzung verbessert, indem er den Heap in Generationsregionen partitioniert, ohne den bestehenden nicht-generationalen Modus zu unterbrechen. Ziel ist es, den generationalen Modus von Shenandoah als Standardmodus in zukünftigen Versionen vorzubereiten.

Bereiten Sie sich darauf vor, die Verwendung von JNI einzuschränken

JEP 472: Wir haben damit begonnen, Laufzeitwarnungen für JNI- und Foreign Function & Memory API-Aufrufe auszugeben, um Entwickler auf eine kommende Version vorzubereiten, die die implizite Unterstützung für native Interaktion reduzieren oder deaktivieren wird. Die JNI-Option wird beibehalten, aber mit klaren Warnungen und einem konsistenten Verhalten, bevor die Einschränkungen verschärft werden.

Entfernen Sie den Windows 32-bit x86 Port

JEP 479: Entfernt den Quellcode und das Build-Skript für die Windows 32-Bit x86-Portierung (veraltet in JDK 21) und entfernt alle spezifischen Pfade und Tests für diese Portierung. Wenn die Unterstützung von Windows 10 für 32-Bit eingestellt wird (EOL Oktober 2025), wird die JDK Build- und Testinfrastruktur vereinfacht.

Dauerhaftes Deaktivieren des Sicherheitsmanagers

JEP 486: Die Plattformspezifikation wurde so geändert, dass der Sicherheitsmanager nicht mehr aktiviert werden kann und seine API in keiner Weise im Code referenziert wird. Damit wird ein veralteter und teurer Sicherheitsmechanismus entfernt, der bereits in Java 17 veraltet war.

Warnung bei Verwendung von Speicherzugriffsmethoden in sun.misc.Unsafe

JEP 498: Das erste Mal, dass eine der Speicherzugriffs-APIs in sun.misc.Unsafe aufgerufen wird, gibt die JVM eine Laufzeitwarnung aus. Diese Methoden sind im JDK 23 veraltet und sollen durch Standardverschlüsselungs- und Speicherschnittstellen ersetzt werden.

Verwerfen Sie den 32-bit x86 Port zum Entfernen

JEP 501: Kündigt die Abschaffung des letzten 32-Bit-x86-Ports (Linux) an und bereitet seine vollständige Entfernung in JDK 25 vor. Nach der Entfernung wird nur noch der agnostische Zero-Port für Plattformen mit 32-Bit-Architektur übrig bleiben.

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 Technologietrends. Schon die Veröffentlichung von Java 23 mit seinen vielen Verbesserungen zeigt, dass eine durchdachte Planung und im Voraus festgelegte und eingehaltene Fristen dazu beigetragen haben, dass Java und sein Ökosystem für viele Entwickler weltweit die Plattform der Wahl für moderne Softwareentwicklung 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 früheren Java-Versionen ist auch Java 23 das kollektive Ergebnis der Mitwirkenden, sowohl Einzelpersonen als auch Organisationen der OpenJDK-Gemeinschaft.

Die Anzahl der Änderungen in den JDK-Updates ist in den letzten Jahren weitgehend konstant geblieben (durchschnittlich etwa 10). Dies ist jedoch auf die regelmäßigen halbjährlichen Veröffentlichungen zurückzuführen, die trotz der relativ kurzen Vorlaufzeit von neuen Sprachfunktionen über kleine Verbesserungen bestehender Funktionen bis hin zu Fehlerbehebungen und Dokumentationsaktualisierungen reichen.

Jede Änderung für ein bestimmtes Ticket wird durch einen separaten Commit an das JDK Bug System Repository dargestellt. Interessanterweise wurden zwischen Java 11 und Java 23 28.724 Probleme gelöst. 20.450 (ca. 71%) wurden von Mitarbeitern von Oracle abgeschlossen, während 8.274 (ca. 29%) von einzelnen Java-Programmierern beigesteuert wurden, die entweder unabhängig oder für andere Organisationen arbeiteten.

Primitive Typen in Mustern, instaceof und switch (Beispiel)

Diese Änderung (JEP 455) beseitigt mehrere Einschränkungen, die bei der Verwendung von primitiven Typen im Mustervergleich bestehen. Code, der primitive Typen und Objekttypen behandelt, kann vereinfacht werden, wenn keine besonderen Änderungen erforderlich sind und beide Typen auf die gleiche Weise behandelt werden können. Erlaubt eine Instanz instanceof zu erlauben, Primitive zu akzeptieren, reduziert den Code für allgemeine Instanzen weiter, da er nun automatisch bedingte Überschreibungen behandeln kann – bei denen ein Wert überprüft werden muss, um sicherzustellen, dass er für den Zieltyp gültig ist.

Deklarationen für den Import von Modulen (Beispiel)

JEP 476 – Ermöglicht es Entwicklern, alle vom Modul exportierten Pakete mit einem einzigen Befehl zu importieren. Dies vereinfacht die Wiederverwendung modularer Bibliotheken, ohne dass der importierte Code im Modul selbst enthalten sein muss. Mit dieser Funktion können Anfänger Drittanbieterbibliotheken und grundlegende Java-Klassen verwenden, ohne lernen zu müssen, wo sie sich in der Paket-Hierarchie befinden.

Implizit deklarierte Klassen und Instanzen von Hauptmethoden (drittes Beispiel)

JEP 477 – Dies ermöglicht es Anfängern, ihre ersten Java-Programme zu schreiben, ohne zunächst die Funktionen für größere und komplexere Programme verstehen zu müssen. Einfache Programme können vereinfachte Deklarationen verwenden und bei Bedarf leicht mit fortgeschritteneren Funktionen erweitert werden. Erfahrene Entwickler können auch die Kürze des Schreibens kleiner Programme genießen.

Flexible Konstruktorkörper (zweite Demonstration)

JEP 482 – Durch die Möglichkeit, dass einige Befehle im Konstruktor vor dem expliziten Aufruf des Konstruktors, also super(…) oder this(…) erscheinen, erhalten Entwickler die Freiheit, das Verhalten von Konstruktoren besser auszudrücken. Das natürlichere Platzieren der Logik, das diese Funktionalität bietet, beseitigt die Notwendigkeit, Teile der Kontroll- und Initialisierungslogik in Hilfsmethoden oder Hilfskonstruktoren unterzubringen. Zum Beispiel kann ein Konstruktor nun Eingabewerte validieren, bevor der Konstruktor der Superklasse aufgerufen wird, wodurch er schnell fehlschlägt und so eine unnötige Instanziierung der Superklasse vermieden wird, falls die Argumente ungültig sind.

Class-File API (zweite Vorschau)

JEP 466 – Dieser JEP schlägt ein API zur Analyse, Generierung und Transformation von Java-Klassendateien vor, das dem Format folgt, das in der Spezifikation der Java Virtual Machine definiert ist. Wenn dieses API als Teil jeder Veröffentlichung bereitgestellt wird, soll es die Herausforderungen entschärfen, die durch den sechsmonatigen Release-Zyklus von Java entstehen, insbesondere für Frameworks, die Klassendateien verarbeiten und mit jeder neuen Version aktualisiert werden müssen, um neue Funktionen schnell zu übernehmen. Sobald diese Funktionalität implementiert ist, sollte sie das JDK selbst von seiner Abhängigkeit von der Drittanbieterbibliothek ASM befreien.

Vektor-API (achter Inkubator)

JEP 469 – ermöglicht es Java-Entwicklern, Vektorberechnungen auszudrücken, die sich zur Laufzeit zuverlässig in optimale Vektoranweisungen auf unterstützten CPU-Architekturen kompilieren lassen und dabei eine bessere Leistung erzielen als entsprechende Skalarberechnungen. Es gibt keine Unterschiede zur 7. Inkubation dieser Funktion in JDK 22. Es ist zu erwarten, dass diese API weiterhin als Inkubations-API zurückkehren wird, bestenfalls mit nur geringfügigen Änderungen, bis die notwendigen Funktionen aus dem Valhalla-Projekt verfügbar sind.

Stream Gatherers (zweite Vorschau)

JEP 473 – Erweitert die Stream-API zur Unterstützung benutzerdefinierter Übergangsoperationen. Dadurch können Stream-Kanäle Daten auf eine Weise umwandeln, die mit den vorhandenen eingebauten Übergangsoperationen nicht ohne weiteres möglich ist. Stream-Collectors bieten die Flexibilität für Zwischenoperationen, die Collectors für Terminaloperationen ermöglichen. Mit dieser Erweiterung werden fünf integrierte Collectors eingeführt.

Strukturierte Gleichzeitigkeit (dritte Vorschau)

JEP 480 – Strukturierte Gleichzeitigkeit ermöglicht es Entwicklern, Gruppen von zusammenhängenden Aufträgen, die auf verschiedenen Threads laufen, als eine einzige Arbeitseinheit zu behandeln, was die Fehlerbehandlung und den Abbruch vereinfacht, die Zuverlässigkeit erhöht und die Beobachtbarkeit verbessert. Diese API unterstützt einen nebenläufigen Programmierstil, der die üblichen Risiken von Abbrüchen und Shutdowns, wie z.B. Thread-Leaks und Abbruchverzögerungen, eliminieren kann.

Scoped Values (dritte Vorschau)

JEP 481 – ermöglicht es der Methode, unveränderliche Daten mit ihren Aufrufern sowohl innerhalb des Threads als auch mit Child-Threads zu teilen. Die Verwendung von Bereichswerten ist einfacher zu begründen als lokale Thread-Variablen. Sie haben auch geringere Platz- und Zeitkosten, insbesondere bei der Verwendung mit virtuellen Threads (JEP 444) und strukturierter Gleichzeitigkeit (JEP 480).

ZGC: Standard-Erzeugungsmodus

JEP 474 – schaltet den Standardmodus des Z Garbage Collectors (ZGC) auf den Generierungsmodus um. Rückmeldungen aus der Verwendung des mit JDK 21 eingeführten Generations-ZGC sowie interne Tests haben bestätigt, dass er in den meisten Anwendungsfällen deutlich besser funktioniert als der Nicht-Generations-ZGC. Dieses JEP verwirft auch den nicht-generativen ZGC-Modus mit der Absicht, ihn in einer zukünftigen Version des JDK zu entfernen.

Anmerkungen zum Markdown-Dokument

JEP 467 – ermöglicht die Verwendung von Markdown anstelle einer Kombination aus HTML und Javadoc @-Tags zum Schreiben von Kommentaren in der Javadoc-Dokumentation. Das neue Format macht es einfacher, die Dokumentation im Quelltext zu lesen und zu verstehen.

Vorschlag zum Entfernen der Speicherzugriffsmethode in sun.misc.unsafe

JEP 471 – Mit der Einführung der fremden Funktions- und Speicher-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 von Methoden in sun.misc.unsafe, die für den Zugriff auf fremden Speicher verwendet werden, angekündigt.

Hier finden Sie die Versionshinweise für Java JDK 23.

Fazit

Java 23 bringt eine Reihe von Verbesserungen, die die Arbeit von Entwicklern vereinfachen und eine effizientere Nutzung der Plattform ermöglichen. Neue Funktionen wie Sprach-, Leistungs- und Tooling-Verbesserungen bestätigen einmal mehr, dass Java für viele Entwickler die bevorzugte Wahl ist. Neue Funktionen wie Sprach-, Leistungs- und Tooling-Verbesserungen bestätigen einmal mehr, dass Java für viele Entwickler die erste Wahl ist.

Java SE 21 (LTS)

Die Veröffentlichung der neuen Version des Java JDK rückt näher und wir haben in unserem Blog beschlossen, einen genaueren Blick auf die neuen Funktionen der Sprache zu werfen. Das geplante Veröffentlichungsdatum ist der 19. September 2023. Es ist jedoch bereits möglich, diese Version im Early Access herunterzuladen und die ersten Experimente zu starten.

Java 21 (nach Java 17) ist wieder eine Version mit Langzeitunterstützung (LTS), was bedeutet, dass Oracle mindestens fünf Jahre lang, bis September 2028, kostenlose Updates und bis September 2031 erweiterte kostenpflichtige Unterstützung anbieten wird.

Java 21 Funktionen, Änderungen und Verbesserungen

Virtuelle Threads (virtuelle Fäden)

Virtuelle Fäden (virtual threads) sind leichte Threads, die das Schreiben, Warten und Verfolgen von hochleistungsfähigen nebenläufigen Anwendungen erheblich vereinfachen. Dazu gehören die Skalierbarkeit von Serveranwendungen, die in Thread-on-Demand-Form geschrieben wurden, indem die Hardware effizient genutzt wird, die Möglichkeit, vorhandenen Code, der die lang.Thread–API verwendet, mit minimalen Änderungen auf virtuelle Threads zu migrieren, und die Möglichkeit, virtuelle Threads mit den vorhandenen JDK-Tools einfach zu debuggen und zu profilieren.

Virtuelle Fasern wurden in JDK 20 und JDK 19 eingeführt und werden in JDK 21 vervollständigt. Virtuelle Threads wurden in JDK 20 und JDK 19 eingeführt und werden in JDK 21 fertiggestellt. Die garantierte Unterstützung für lokale Thread-Variablen wird also dafür sorgen, dass viele bestehende Bibliotheken ohne Änderungen mit virtuellen Threads verwendet werden können.

Sequenced collections (sequenzierte Sammlungen)

Sequentielle Sammlungen, bzw. Sammlungen mit Ordnung ist eine weitere interessante neue Funktion. JDK 21 führt das Design von Sammlungen mit Ordnung ein und stellt Schnittstellen für Sammlungen mit definierter Ordnung zur Verfügung. Jede Kollektion hat ein klar definiertes erstes, zweites Element und so weiter, bis hin zum letzten Element. Es werden einheitliche APIs für den Empfang von ersten und letzten Elementen und für die Verarbeitung von Elementen in umgekehrter Reihenfolge bereitgestellt. Die Motivation für diesen Vorschlag ist die Tatsache, dass das Java-Sammlungs-Framework keinen Sammlungstyp hat, der eine Folge von Elementen mit einer definierten Reihenfolge darstellt. Es fehlt auch ein einheitlicher Satz von Operationen, die für diese Sammlungen gelten. Diese Lücken sind ein Problem und eine Quelle von Beschwerden. Der Vorschlag sieht vor, Schnittstellen für Sequenzen von Sammlungen, Sets und Maps zu definieren und sie in die bestehende Hierarchie der Sammlungstypen aufzunehmen. Alle diese neuen Methoden haben vordefinierte Implementierungen.

Record pattern (Aufzeichnungsmuster)

Mit Aufzeichnungsmustern ist es möglich, Aufzeichnungswerte zu dekonstruieren. Probendatensätze und Probentypen können verschachtelt werden, was eine leistungsstarke, deklarative und kombinierbare Datenabfrage und -verarbeitung ermöglicht. Zu den Entwurfszielen gehören die Erweiterung des Musterabgleichs, um Instanzen von Datensatzklassen zu zerstören, und das Hinzufügen verschachtelter Muster, um die Komposition von Datenabfragen zu ermöglichen. Diese Funktion wurde parallel zum Mustervergleich für Switch-Ausdrücke entwickelt.

Pattern matching for switch (Mustervergleich für Switch)

Mit dieser Funktion kann ein Switch-Ausdruck/Befehl gegen mehrere Muster getestet werden, von denen jedes eine bestimmte Aktion hat, was einen sicheren und präzisen Ausdruck komplexer Datenabfragen ermöglicht. Diese Funktion wurde ursprünglich in JDK 17 vorgeschlagen, in den nachfolgenden Versionen modifiziert und sollte in JDK 21 auf der Grundlage der Rückmeldungen und Erfahrungen von Java-Entwicklern vervollständigt und modifiziert werden. Zu den wichtigsten Änderungen im Vergleich zu früheren Versionen von JEP gehören die Entfernung von Klammern in Mustern und die Zulassung von qualifizierten Aufzählungskonstanten sowie die Erhöhung der Sicherheit von Ausdrücken und Switch-Anweisungen, indem verlangt wird, dass alle möglichen Eingabewerte abgedeckt werden. Ein weiteres Ziel ist es, sicherzustellen, dass bestehende Switch-Writes ohne Änderungen funktionsfähig bleiben und mit der gleichen Semantik ausgeführt werden.

String templates (Zeichenfolgenvorlagen)

Hierbei handelt es sich um ein Feature in Form eines JDK 21-Beispiels, das die bestehenden String-Literale und Textblöcke in Java ergänzt, indem es diesen Text mit eingebetteten Ausdrücken und Prozessoren kombiniert, um spezielle Ergebnisse zu erzielen. Dieses Sprachmerkmal und die API sollen das Schreiben von Java-Programmen vereinfachen, indem sie es leicht machen, Zeichenketten auszudrücken, die zur Laufzeit berechnete Werte enthalten. Es verspricht, die Lesbarkeit von Ausdrücken zu verbessern, die Programmsicherheit zu erhöhen, die Flexibilität zu bewahren und die Verwendung von APIs zu vereinfachen, die Strings akzeptieren, die in anderen Sprachen als Java geschrieben wurden. Die Funktion ermöglicht auch die Entwicklung von Nicht-String-Ausdrücken, die durch die Kombination von Textliteralen und eingebetteten Ausdrücken erstellt werden.

Unnamed patterns and variables (unbenannte Muster und Variablen)

Diese Funktion verbessert die Lesbarkeit des Codes und die Wartung, da Muster erstellt werden können, ohne dass ein Komponentenname oder -typ angegeben werden muss. Unbenannte Variablen können initialisiert werden, werden aber nicht verwendet. Das Ziel ist es, unnötige verschachtelte Muster zu eliminieren und nicht verwendete Variablen zu identifizieren.

Unbenannte Klassen und Instanzhauptmethoden

Diese Funktion zielt darauf ab, das Schreiben erster Java-Programme zu vereinfachen, bei denen Studenten möglicherweise nicht sofort die Sprachfunktionen verstehen, die für komplexere Projekte vorgesehen sind. Damit kann man einfache Programme erstellen und sie nach und nach mit fortgeschrittenen Funktionen erweitern.

Structured concurrency (strukturierte Nebenläufigkeit)

strukturierte Nebenläufigkeit vereinfacht die Programmierung in einer gleichzeitigen Umgebung, indem eine API verwendet wird, die Gruppen von zusammenhängenden Aufgaben als Arbeitseinheiten verwaltet. Dies verbessert das Fehlermanagement, was die Zuverlässigkeit und Beobachtbarkeit erhöht. Diese Funktion, die zuvor in JDK 20 und JDK 19 getestet wurde, wird nun als Beispiel-API im Paket util.concurrent unterstützt.

Scoped values (skalierte Werte)

Die Vorschauversion dieser Funktion ermöglicht die gemeinsame Nutzung unveränderlicher Daten zwischen Threads und Komponenten. Skalierte Werte sind lokalen Thread-Variablen vorzuziehen, insbesondere wenn man eine große Anzahl virtueller Threads verwendet. Diese Funktion verbessert die Lesbarkeit und Robustheit des Codes.

Prepare to disallow the dynamic loading of agents

Deaktivieren des dynamischen Ladens von Agenten – diese Änderung zielt darauf ab, die Integrität der JVM zu verbessern, indem sie vor dem dynamischen Laden von Agenten warnt, während die Anwendung läuft. Das Ziel ist es, das Gleichgewicht zwischen Serviceänderungen und Code-Integrität zu verbessern und sicherzustellen, dass die meisten Tools von dieser Änderung nicht betroffen sind.

Key encapsulation mechanism API (Schlüsselkapselungsmechanismus API )

Diese Funktion ermöglicht die Verwendung von Algorithmen zur Sicherung symmetrischer Schlüssel mit ö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 einer Vielzahl von Protokollen und kryptographischen Schemata zu verwenden.

Generation ZGC

Diese Funktion zielt darauf ab, die Anwendungsleistung zu verbessern, indem separate Generationen für junge und alte Objekte verwendet werden. Generational ZGC ermöglicht eine effizientere Sammlung von jungen Objekten und führt zu einem geringeren Speicherverbrauch und einer geringeren Belastung durch die Garbage Collection (Sammeln von unnötig zugewiesenem Speicher).

Foreign function & memory API

Ermöglicht die Interoperabilität von Java-Programmen mit Code und Daten außerhalb der Java-Laufzeitumgebung. Es ermöglicht den Aufruf externer Bibliotheken und den sicheren Zugriff auf den Speicher und ersetzt damit JNI(Java Native Interface).

Vector-API (Vektor-API)

Mit dieser API können Berechnungen vektoriell durchgeführt werden, was zu einer besseren Leistung als bei 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 zielt darauf ab, den 32-Bit-Port für Windows x86 in einer zukünftigen Version zu entfernen. Windows 10, das letzte Betriebssystem von Microsoft, das den 32-Bit-Modus unterstützt, beendet seinen Lebenszyklus im Oktober 2025.

Zusätzlich zu diesen Funktionen ist JDK 21 auch dabei, die Benennung von Netzwerkschnittstellen in Windows zu ändern. Es ist auch eine experimentelle Funktion „kompakte Objekt-Header“ geplant, um die Größe der Objekt-Header in der JVM zu reduzieren und damit den Speicherplatz zu verringern.

Wenn du dich für die neuen Funktionen von Java JDK 21 interessierst und mehr darüber erfahren möchtest, empfehlen wir dir einen Besuch auf der offiziellen OpenJDK-Website.

Java SE 20

Oracle kündigte 21. März 2023 hat Oracle die Verfügbarkeit der neuesten Version der weltweit beliebtesten Programmiersprache und Entwicklungsplattform bekannt gegeben. In diesem Artikel werden wir uns auf einige der wichtigsten Neuigkeiten konzentrieren.

Java SE 20 (Oracle JDK 20) bringt tausende Verbesserungen in den Bereichen Leistung, Stabilität und Sicherheit mit, einschließlich Plattformverbesserungen, die Entwicklern helfen, die Produktivität zu steigern und Innovationen sowie Wachstum in ihren Organisationen zu fördern. Es sind bereits über 25 Jahre vergangen, seit Java Entwicklern ermöglicht, neue Generationen von robusten, skalierbaren und sicheren Anwendungen zu entwerfen und zu entwickeln.

Oracle JDK 20 ist keine Version mit langfristiger Unterstützung (LTS – long-term support), daher wird es nur Updates erhalten, bis es nach sechs Monaten durch JDK 21 ersetzt wird.

Das letzte LTS-Release von Java bleibt somit Oracle JDK 17 (veröffentlicht am 14. September 2021). Jedoch hat Oracle Pläne bekannt gegeben, den Zeitraum zwischen LTS-Veröffentlichungen von drei auf zwei Jahre zu verkürzen, daher ist JDK 21 als nächstes LTS für September 2023 geplant.

Die Anzahl der Änderungen in den JDK-Veröffentlichungen hat sich im Laufe der Zeit nicht stark verändert, aber unter dem sechsmonatigen Druck, neue Versionen herauszubringen, hat sich das Tempo der Bereitstellung neuer Funktionen und Verbesserungen, die für die Produktion bereit sind, stark erhöht. Anstelle von Tausenden von Fixes und fast hundert JEPs (Java Enhancement Proposals) alle paar Jahre, wie es früher mit den Hauptversionen der Fall war, werden Verbesserungen nun in bescheideneren Releases auf einem vorhersehbareren sechsmonatigen Zeitplan geliefert. Die Änderungen reichen von bedeutenden neuen Funktionen über kleine Verbesserungen bis hin zur Routine-Wartung, Fehlerbehebungen und der Verbesserung der Dokumentation. Jede Änderung wird durch einen eigenen Commit und ein Issue im JDK-Fehlerverwaltungssystem repräsentiert.

Neuigkeiten im Java JDK 20

Java 20 JDK enthält sieben JEPs (Java Enhancement Proposals), die darauf abzielen, die Produktivität der Entwickler zu steigern, die Java-Sprache zu verbessern sowie die Leistung, Stabilität und Sicherheit der Plattform zu erhöhen. Diese Funktionen umfassen virtuelle Threads, das Vector API, strukturierte Konkurrenz, begrenzte Werte, API für fremde Funktionen und Speicher, Record-Patterns und Pattern-Matching für Switch-Anweisungen.

Virtuelle Fäden (virtual threads)

Virtuelle Threads sind leichtgewichtige Threads, die die Anstrengung beim Schreiben, Warten und Debuggen von hochleistungsfähigen parallelen Anwendungen reduzieren. Das sind Instanzen der Klasse java.lang.Thread, die jedoch nicht an ein spezifisches Betriebssystem-Thread gebunden sind. Wenn der Code, der in einem virtuellen Thread läuft, eine blockierende Ein-/Ausgabeoperation aufruft, suspendiert die Java Laufzeitumgebung das virtuelle Thread, bis es wieder fortgesetzt werden kann. Wenn der Code, der in einem virtuellen Thread läuft, eine blockierende Ein-/Ausgabeoperation aufruft, pausiert die Java Laufzeitumgebung den virtuellen Thread, bis er wieder fortgesetzt werden kann.

Virtuelle Threads sind ideal für die Ausführung von Aufgaben geeignet, die einen Großteil ihrer Zeit mit Blockieren verbringen, oft beim Warten auf den Abschluss von Ein-/Ausgabeoperationen. Jedoch sind sie nicht für langwierige und prozessorintensive Operationen geeignet.

Vektor API Vorschlag (vector API proposal)

Der Vektor-API-Vorschlag ist eine neue Funktion in Java 20 JDK, die ein API einführt, um Vektorberechnungen auszudrücken, die zuverlässig auf optimierte Vektoranweisungen auf unterstützten CPU-Architekturen übersetzt werden können. Dadurch wird eine Leistung erzielt, die über der von äquivalenten skalaren Berechnungen liegt.

Das Ziel ist es, ein klares und prägnantes API bereitzustellen, das in der Lage ist, eine breite Palette von Vektorberechnungen auszudrücken, die aus Sequenzen von Vektoroperationen bestehen, die in Schleifen kombiniert sind und möglicherweise auch mit Flusskontrolle gesteuert werden können. Es sollte möglich sein, eine Berechnung auszudrücken, die in Bezug auf die Größe des Vektors oder die Anzahl der Bahnen pro Vektor generisch ist, so dass solche Berechnungen auf Hardware, die unterschiedliche Vektorgrößen unterstützt, übertragbar sind.

Strukturierte Nebenläufigkeit (structured concurrency)

Dies ist eine neue Funktion im Java SE 20 JDK, die eine API bereitstellt, um die Programmierung von Multithreading-Anwendungen zu vereinfachen und mehrere Aufgaben, die in verschiedenen Threads laufen, als eine einzige Arbeitseinheit zu behandeln. Die Fehlerbehandlung und das Abbrechen von Threads sind 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 begrenzten Werten durch Threads zu unterstützen, die im Aufgabenbereich erstellt wurden.

Begrenzte Werte (scoped values)

Begrenzte Werte sind eine Neuerung in Java 20 JDK, die es Entwicklern ermöglicht, unveränderliche Daten innerhalb und zwischen Threads zu speichern und zu teilen. Dieses neue API wird in Java 20 JDK als Inkubatorfunktion eingeführt und ist in JEP 439 beschrieben.

In Java 20 JDK wird die neue Klasse jdk.incubator.concurrent.ScopedValue <> 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 Fremdfunktionen und Speicher (Fremdfunktionen- und Speicher-API)

Diese neue Funktion im Java 20 JDK ermöglicht es Java-Programmen, mit Code und Daten außerhalb der Java-Laufzeitumgebung zusammenzuarbeiten. Durch den effizienten Aufruf fremder Funktionen (Code außerhalb der Java Virtual Machine [JVM]) und den sicheren Zugriff auf fremden Speicher (nicht von der JVM verwalteter Speicher) ermöglicht diese Funktion Java-Programmen den Aufruf nativer Bibliotheken und die Verarbeitung nativer Daten, ohne dass die Java Native Interface benötigt wird. Das erhöht die Benutzerfreundlichkeit, Leistung und Sicherheit.

Muster von Aufzeichnungen record patterns)

Diese Verbesserung erweitert die Programmiersprache Java, indem sie es den Benutzern ermöglicht, Record Patterns und Typmuster zu verschachteln, um eine starke, deklarative und zusammengesetzte Form der Navigation und Datenverarbeitung zu schaffen. Dies hilft, die Produktivität der Entwickler zu steigern, indem es ihnen ermöglicht, die Mustererkennung zu erweitern, um komplexere Datenabfragen zu ermöglichen.

Mustervergleich für Switch-Anweisungen und Ausdrücke

Es ermöglicht Entwicklern, Muster in Switch-Anweisungen zu verwenden. Im Vergleich zur Verwendung von Konstanten bietet dies eine höhere Flexibilität und Ausdruckskraft.

Fazit

Das neue Java SE 20 JDK-Release bringt neben Fehlerkorrekturen auch sieben Vorschläge zur Verbesserung des JDK, um die Produktivität der Entwickler zu steigern, die Java-Sprache zu verbessern sowie die Leistung, Stabilität und Sicherheit der Plattform zu erhöhen.

Ihr könnt es 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, Unterstützung für den neuesten Apple M1-Chip und Unterstützung für versiegelte (sealed) Klassen mit sich brachte. Auch Sprachverbesserungen und die Entfernung der Komplikationen von Ahead-of-Time und Just-in-Time fehlen nicht.

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. Die Quellcodes von OpenJDK wurden von Mercurial nach Git migriert. Der Grund dafür waren die Größe der Metadatendateien, bessere Werkzeuge und Hosting-Möglichkeiten.

Quelle: java SE 16

Java SE 15

Java SE 15 wurde im September 2020 veröffentlicht und brachte mit sich Drei wichtige Aktualisierungen:

Textblöcke als Standard

Textblöcke, die als Vorschau in Java 13 eingeführt wurden, sind nun Teil des Sprachstandards geworden.

Sealed Klassen

Die Zugriffsmodifikatoren public, protected und private bieten eine sehr grundlegende Kontrolle. Mit den Schlüsselwörtern sealed, non-sealed und permit kann der Programmierer an der Vererbungshierarchie herumspielen. Das Ziel von versiegelte (sealed) Klassen ist es, einzelnen Klassen die Möglichkeit zu geben, zu deklarieren, welche Typen als Subtypen verwendet werden können. Dies gilt auch für Schnittstellen und die Festlegung, welche Typen sie implementieren können.

In diesem Beispiel haben wir eine abstrakte Klasse namens Person deklariert. Wir haben auch festgelegt, dass die einzigen Klassen, die sie erweitern können, Employee und Manager sind. Das Erweitern einer versiegelte (sealed) Klasse erfolgt auf die gleiche Weise wie heute in Java mit dem Schlüsselwort extends:

 

Jede Klasse, die eine versiegelte (sealed) Klasse erweitert, muss selbst als sealed, non-sealed oder final deklariert werden. Dadurch wird sichergestellt, dass die Klassenhierarchie endlich bleibt und dem Compiler bekannt ist.

Versteckte Klassen

Das Ziel von Hidden Classes ist es, Klassen zu ermöglichen, die nicht sichtbar sind. Das bedeutet, dass sie nicht von anderen Klassen erweitert werden können und auch nicht durch Reflexion entdeckt werden können. Klassen, wie diese, haben üblicherweise einen kurzen Lebenszyklus, daher sind sie so gestaltet, dass sie vor allem effizient sind. 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 wichtige Verbesserungen:

Switch als Standard

Der Switch-Ausdruck, der in Java 12 als Preview eingeführt und in Version 13 verbessert wurde, ist mittlerweile ein Sprachstandard.

Verbesserung NullPointerException

NullPointerException hatte in der Vergangenheit nicht besonders viel aussagekräftigen Wert. Der Grund dafür war, dass durch ihn nur festgestellt werden konnte, dass ein bestimmter Wert in einer Datei null war. In der neuen Version ist jedoch alles anders. Die Funktion wurde erweitert und die Programmierer wissen nun endlich, welche Variable die Ausnahme verursacht hat.

Java records

Die Aufzeichnungen wurden eingeführt, um die wiederholte Erstellung von Standardcode in POJO-Datenmodellen zu reduzieren. Sie vereinfachen die alltägliche Entwicklung, erhöhen die Effizienz und minimieren das Risiko menschlicher Fehler erheblich. Zum Beispiel kann ein Datenmodell für einen Benutzer mit einer ID und einem 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.

Musterübereinstimmung für instanceof

Version 14 führte den Mustervergleich ein, umden Code zu vereinfachen. Ohne die neue Funktion würde der Code so aussehen:

Dank der neuen Version von Java 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 bringt zwei wichtige Verbesserungen mit sich:

Textblöcke

Die neue Textblockfunktion erleichtert den Entwicklern das Lesen von mehrzeiligem Text. Es verwendet drei Anführungszeichen, ähnlich wie Python und Groovy.

Darüber hinaus sind alle Funktionen der Klasse String verfügbar.

Verbesserungen des switch-Ausdrucks

Java 13 verbessert den switch-Ausdruck aus Version 12 um das Schlüsselwort „yield„. Mit „yield“ können Werte aus einem switch-Ausdruck zurückgegeben werden.

Quelle: java SE 13

Java SE 12

Die Version 12 wurde im März 2019 veröffentlicht und brachte nur eine signifikante Verbesserung mit sich. Es war die alternative Schreibweise für switch. Das folgende Beispiel vergleicht die alte und die neue Schreibweise von switch. Der Code unterscheidet zwischen Werktagen und Wochenendtagen.

Der Code in der neuen Syntax sieht viel sauberer und kürzer aus. Die neue Switch-Form entfernt auch die Notwendigkeit der Break-Schlüsselwörter. Das bedeutet, dass wenn der Code die erste Übereinstimmung findet, er aufhört zu arbeiten. Ein weiterer Unterschied besteht darin, dass einer Variablen in einer switch-Anweisung direkt ein Wert zugewiesen werden kann.

Quelle: java SE 12

Java SE 11 (LTS)

Laut der jährlichen Umfrage von Snyk war Java 11 die meistgenutzte Version im Jahr 2021. Sie wurde von bis zu 61,5 % der Befragten verwendet. Nur 12 % der Befragten hatten die Programmiersprache auf die neueste Version aktualisiert, die zum Zeitpunkt der Umfrage Java 15 war.

Interessant waren auch die Antworten auf die Frage nach den Gründen, warum die Leute nicht auf eine neuere Version umgestiegen sind. Die Mehrheit stimmte darin überein, dass sie nicht in der Lage oder bereit ist, Java alle 6 Monate zu migrieren. Andere, etwa 51 %, behaupten, dass sie keine Veränderungen brauchen, weil ihre aktuelle Umgebung gut funktioniert.

Weitere Gründe, warum die Umfrageteilnehmer bei älteren Versionen bleiben, sind:

• die hohen Kosten der Migration,
• das Zögern der Kunden, zu migrieren,
• die neue Version keine besonderen Verbesserungen aufweist,
• Anwendungsserver oder Bibliotheken unterstützen die neuesten Versionen nicht.

Aus der Umfrage von 2020 ging hervor, dass die Strategie der Mehrheit der Entwickler (55 %) darin besteht, sich an langfristige Releases zu halten. Trotzdem geben bis zu 22 % der Befragten an, dass sie planen zu entscheiden, ob sie upgraden werden oder nicht. Sie möchten herausfinden, ob die neu eingeführten Funktionen wichtig genug sind, um die Migration zu rechtfertigen.

Java SE 11 wurde sechs Monate nach Version 10 veröffentlicht, also im September 2018. Sie brachte zwei wesentliche Änderungen mit sich:

Ausführen von Java-Dateien

Die wichtigste Änderung in dieser Version ist, dass der Programmierer die ava-Quelldateien nicht mehr explizit mit dem Befehl javac kompilieren muss.

Stattdessen kann die Datei direkt mit dem Befehl java ausgeführt werden

Verwendung der Syntax für lokale Variablen

Java 11 bietet Unterstützung für die Verwendung der Syntax lokaler Variablen in Lambda-Parametern. Die Funktion kann verwendet werden, um Modifikatoren auf lokale Variablen anzuwenden, zum Beispiel zur Definition einer Annotation.

Quelle: java SE 11

Java SE 10

Oracle hat Java SE 10 im März 2018 veröffentlicht. Für Entwickler brachte es zwei wichtige Änderungen:

OpenJDK

Um die Java-Community freundlicher zu gestalten, begann Oracle damit, OpenJDK-Binärdateien als das primäre JDK der Zukunft zu fördern. Das Problem ist jedoch, dass man für erweiterte Unterstützung älterer Java-Versionen zahlen muss.

Die var-Variable

Die var-Variable ist nichts Neues, da sie auch in anderen Programmiersprachen existiert. Ihr Hauptvorteil ist, dass sie die Beredsamkeit der Zunge verringert. In der Praxis bedeutet dies, dass man mit ihrer Hilfe lange Objektnamen vermeiden oder dieselben Namen nicht zweimal schreiben muss.

Programmierer könnten sich jedoch fragen, was der Unterschied zwischen var und Object ist. Das Schlüsselwort var bedeutet, dass du möchtest, dass der Compiler den Typ selbst feststellt. Auf der anderen Seite kannst du mit Object eine Instanz deines Objekts in den Typ Object umwandeln. Das bedeutet, dass du zwar die allgemeinen Methoden der Klasse Object verwenden kannst, aber nicht die spezifischen Methoden deiner spezifischen Klasse. Dies führt zu einem Kompilierungsfehler.

Quelle: java SE 10

Java SE 9

Java SE 9 wurde im September 2017 veröffentlicht und brachte einige Änderungen mit sich. Aber nicht alle von ihnen waren bedeutend und wichtig. Dies sind die drei wichtigsten:

Modularität – Jigsaw Project

Die wichtigste Änderung in der Java 9-Umgebung war das Modularitätssystem, das als Jigsaw-Projekt bezeichnet wurde. Ein Modul ist eine Gruppe von Code, die durch bestimmte Merkmale gekennzeichnet ist. Die Modularitätsfunktion teilt die Programmiersprache in kleinere Module auf, um zu bieten:

• Schattierung,
• Verringerung von Konflikten zwischen Versionen,
• Hinzufügen von Verkapselung,
• bessere Sicherheit,
• höhere Leistung,
• angepasstes Laufzeit-JDK mit geringerem Umfang.

Um ein neues Modul zu erstellen, benötigst du eine module-info.java Datei in deinem src/main/java Verzeichnis. Drinnen kannst du deine Modulanforderungen definieren.

Private Methoden in Java-Schnittstellen

Eine weitere Funktion von Java 9 ermöglicht das Schreiben privater und statischer Methoden in Schnittstellen, um überflüssigen Code zu vermeiden.

Das Java-Kommandozeilen-Tool 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 diese schnell zu testen. Es ist hervorragend zum Testen kleiner Code-Snippets geeignet, die ansonsten das Erstellen einer neuen Klasse mit einer main-Methode erfordern würden.

JShell befindet sich im Ordner <JAVA_HOME>/bin und kann durch Eingabe von jshell in der Befehlszeile gestartet werden, um sofort mit dem Schreiben von Code zu beginnen.

Das interaktive Java-Tool JShell wird mit einer Verlaufs-Funktion und automatischer Vervollständigung geliefert. Es bietet auch Funktionen wie das Speichern und Laden von Dateien sowie das Verwalten aller oder einzelner Codezeilen.

Quelle: java SE 9

Artikel teilen

Java JDK: Versionsübersicht, Unterschiede zwischen LTS, SE, JRE und Java 24

Über den Autor

Jozef Wagner

Leitender Java-Entwickler

Ich programmiere seit mehr als 10 Jahren in Java, arbeite derzeit bei msg life Slovakia als leitender Java-Programmierer und helfe Kunden bei der Umsetzung ihrer Anforderungen in die Versicherungssoftware Life Factory. In meiner Freizeit entspanne ich gerne in den Bergen oder spiele ein gutes Computerspiel.