{"id":9160,"date":"2025-09-29T07:50:04","date_gmt":"2025-09-29T07:50:04","guid":{"rendered":"https:\/\/msgprogramator.sk\/?p=9160"},"modified":"2025-10-09T13:44:19","modified_gmt":"2025-10-09T13:44:19","slug":"java-jdk","status":"publish","type":"post","link":"https:\/\/msgprogramator.sk\/de\/java-jdk\/","title":{"rendered":"Java JDK: \u00dcberblick \u00fcber Versionen, Unterschiede zwischen LTS, SE, JRE und Java 24"},"content":{"rendered":"<p>Wir bieten dir einen \u00dcberblick \u00fcber die Java-Versionen, einen Vergleich von <strong data-start=\"678\" data-end=\"700\">Java JDK-, SE- und LTS-Releases<\/strong> sowie eine Zusammenfassung der wichtigsten \u00c4nderungen in den neuesten Versionen \u2013 einschlie\u00dflich Java 24, das die Grenzen der Sprache erneut ein St\u00fcck weiter verschiebt. So erh\u00e4ltst du ein klares Bild davon, welche Hauptunterschiede zwischen den Versionen bestehen, welche neuen Funktionen sie bieten und worauf du bei einer Migration achten solltest.<\/p>\n<h2>Java-Versionen JDK, SE, LTS und Ver\u00f6ffentlichungsfrequenz<\/h2>\n<p>Java wird seit \u00fcber zwei Jahrzehnten kontinuierlich weiterentwickelt, und um mit den modernen Anforderungen der Softwareentwicklung Schritt zu halten, ist die Sprache auf ein halbj\u00e4hrliches Release-Modell umgestiegen. Die erste agile Version war Java SE 9, die im September 2017 ver\u00f6ffentlicht wurde. Version Java 10 erschien dann ein halbes Jahr sp\u00e4ter. Seitdem erscheint alle sechs Monate eine neue Version des <strong data-start=\"296\" data-end=\"308\">Java JDK<\/strong>, die Verbesserungen, Fehlerbehebungen und experimentelle Funktionen mit sich bringt.<\/p>\n<p>F\u00fcr Unternehmen und Entwickler ist es entscheidend, den Unterschied zwischen LTS-Versionen (Long-Term Support), die Stabilit\u00e4t und langfristige Unterst\u00fctzung gew\u00e4hrleisten, und Non-LTS-Versionen zu verstehen, die eher f\u00fcr das Testen neuer Funktionen und die Vorbereitung auf zuk\u00fcnftige LTS-Releases gedacht sind.<\/p>\n<figure id=\"attachment_9126\" aria-describedby=\"caption-attachment-9126\" style=\"width: 720px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-9124 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-version-1-21.webp\" alt=\"Java Versionen 1-21\" width=\"720\" height=\"960\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-version-1-21.webp 720w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-version-1-21-225x300.webp 225w\" sizes=\"auto, (max-width: 720px) 100vw, 720px\" \/><figcaption id=\"caption-attachment-9126\" class=\"wp-caption-text\">\u00dcberblick \u00fcber Java Version 1-21, Quelle <a href=\"https:\/\/en.wikipedia.org\/wiki\/Java_version_history\">Wikipedia<\/a> Lizenz CC BY-SA 4.0.<\/figcaption><\/figure>\n<figure id=\"attachment_9123\" aria-describedby=\"caption-attachment-9123\" style=\"width: 960px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-9121 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-versions-22-25-1.webp\" alt=\"Java Versionen 22-25\" width=\"960\" height=\"349\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-versions-22-25-1.webp 960w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-versions-22-25-1-300x109.webp 300w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/09\/Java-versions-22-25-1-768x279.webp 768w\" sizes=\"auto, (max-width: 960px) 100vw, 960px\" \/><figcaption id=\"caption-attachment-9123\" class=\"wp-caption-text\">\u00dcberblick \u00fcber die Java-Versionen 22\u201325, Quelle <a href=\"https:\/\/en.wikipedia.org\/wiki\/Java_version_history\">Wikipedia<\/a>, Lizenz CC BY-SA 4.0.<\/figcaption><\/figure>\n<h2>Java JDK (<strong data-start=\"42\" data-end=\"77\">Java Development Kit<\/strong>)<\/h2>\n<p><strong data-start=\"42\" data-end=\"77\">Das Java JDK (Java Development Kit)<\/strong> ist das offizielle Werkzeugpaket zur Entwicklung von Anwendungen in Java. Es enth\u00e4lt den Compiler<code class=\"\" data-line=\"\">javac<\/code>, der Quellcode in Bytecode \u00fcbersetzt, der auf der Java Virtual Machine (JVM) ausgef\u00fchrt 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\u00fcr jeden Entwickler, da es eine vollst\u00e4ndige Umgebung zum Schreiben, Kompilieren, Ausf\u00fchren und Debuggen von Code bereitstellt.<\/p>\n<p>Neben den grundlegenden Werkzeugen bietet das JDK auch verschiedene Hilfsprogramme wie <code class=\"\" data-line=\"\">javadoc<\/code> zum Erzeugen von Dokumentation direkt aus dem Quellcode oder <code class=\"\" data-line=\"\">jlink<\/code> zum Erstellen eigener Java-Laufzeit-Images. Es ist wichtig, das JDK vom <strong data-start=\"296\" data-end=\"330\">JRE (Java Runtime Environment)<\/strong> zu unterscheiden, das ausschlie\u00dflich zum Ausf\u00fchren bereits fertiger Anwendungen dient. W\u00e4hrend das JRE von Endbenutzern verwendet wird, ist das JDK in erster Linie f\u00fcr Entwickler gedacht \u2013 ohne es w\u00e4re die Erstellung und das Testen von Java-Anwendungen nicht m\u00f6glich.<\/p>\n<h2>Java SE (<strong data-start=\"73\" data-end=\"118\">Java-Plattform<\/strong>, Standard Edition)<\/h2>\n<p data-start=\"73\" data-end=\"502\"><strong data-start=\"73\" data-end=\"118\">Java SE (Java Platform, Standard Edition)<\/strong> ist die grundlegende Edition der Java-Plattform, die die standardisierte API, Syntax und das Verhalten der Sprache definiert. Sie enth\u00e4lt 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 \u2013 von einfachen Desktop-Programmen bis hin zu umfangreichen Enterprise-L\u00f6sungen.<\/p>\n<p data-start=\"504\" data-end=\"853\">Java SE ist kein Entwicklungswerkzeug wie das JDK, sondern eher ein \u201eStandard\u201c 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\u00fcssen. F\u00fcr Entwickler bietet sie die Sicherheit, dass Code, der gem\u00e4\u00df Java SE geschrieben wurde, in jeder mit diesem Standard kompatiblen Umgebung funktioniert.<\/p>\n<h2 data-start=\"504\" data-end=\"853\"><strong data-start=\"296\" data-end=\"330\">JRE (Java Runtime Environment)<\/strong><\/h2>\n<p data-start=\"128\" data-end=\"520\">Das <strong data-start=\"128\" data-end=\"162\">Java Runtime Environment (JRE)<\/strong> ist eine Laufzeitumgebung zur Ausf\u00fchrung von in Java geschriebenen Anwendungen. Es enth\u00e4lt die Java Virtual Machine (JVM), die f\u00fcr die \u00dcbersetzung und Ausf\u00fchrung des Bytecodes verantwortlich ist, sowie die grundlegenden Bibliotheken, die f\u00fcr den Betrieb von Programmen erforderlich sind. Im Gegensatz zum JDK bietet das JRE keine Entwicklungswerkzeuge \u2013 seine Aufgabe besteht ausschlie\u00dflich darin, sicherzustellen, dass eine fertige Anwendung auf einem Computer oder Server ausgef\u00fchrt werden kann.<\/p>\n<p data-start=\"522\" data-end=\"788\">Das JRE eignet sich daher f\u00fcr Endbenutzer oder Produktionsumgebungen, in denen Anwendungen lediglich ausgef\u00fchrt, aber nicht weiterentwickelt werden. Ein Entwickler kommt in der Regel mit dem JDK aus (das das JRE automatisch enth\u00e4lt), w\u00e4hrend das JRE allein von denen genutzt wird, die Anwendungen nur betreiben.<\/p>\n<h2 data-start=\"522\" data-end=\"788\"><strong data-start=\"140\" data-end=\"172\">Java LTS (Long-Term Support)<\/strong><\/h2>\n<p data-start=\"140\" data-end=\"573\"><strong data-start=\"140\" data-end=\"172\">Java LTS (Long-Term Support)<\/strong> steht f\u00fcr Java-Versionen, die eine garantierte langfristige Unterst\u00fctzung von Oracle oder anderen Anbietern (Adoptium, Red Hat usw.) erhalten. Jede LTS-Version erscheint ungef\u00e4hr alle drei Jahre und bietet Unternehmen Stabilit\u00e4t, Sicherheitsupdates und Fehlerbehebungen \u00fcber einen Zeitraum von 8 oder mehr Jahren. Genau deshalb sind LTS-Releases die h\u00e4ufigste Wahl f\u00fcr Enterprise-Projekte, bei denen Zuverl\u00e4ssigkeit und minimales Risiko im Betrieb entscheidend sind.<\/p>\n<p data-start=\"575\" data-end=\"977\">Im Gegensatz zu non-LTS-Versionen, die nur 6 Monate lang unterst\u00fctzt werden und haupts\u00e4chlich 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\u00e4chsten (z. B. von Java 11 auf 17 oder 21), um Probleme mit kurzlebigen Releases zu vermeiden. LTS bildet somit eine sichere Grundlage f\u00fcr langfristige Projekte und Produktionsumgebungen.<\/p>\n<h2>Unterschiede zwischen Java JDK, SE, LTS, JRE<\/h2>\n<table>\n<caption>Vergleichstabelle: LTS vs. non-LTS Java-Versionen + JDK, SE, JRE<\/caption>\n<thead>\n<tr>\n<th>Kriterium<\/th>\n<th>LTS (Long-Term Support)<\/th>\n<th>non-LTS<\/th>\n<th>JDK (Java Development Kit)<\/th>\n<th>Java SE (Standard Edition)<\/th>\n<th>JRE (Java Runtime Environment)<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Dauer des Supports<\/td>\n<td>8+ Jahre (Oracle, Hersteller-Support)<\/td>\n<td>6 Monate<\/td>\n<td>Enth\u00e4lt den Compiler <code class=\"\" data-line=\"\">javac<\/code>, Tools, Debugger, Dokumentation, Bibliotheken<\/td>\n<td>Plattform und API durch Standard definiert (JLS, JVM, Bibliotheken)<\/td>\n<td>Enth\u00e4lt JVM + Basisbibliotheken, ohne Entwickler-Tools<\/td>\n<\/tr>\n<tr>\n<td>Ver\u00f6ffentlichung<\/td>\n<td>Alle 3 Jahre (z.B. Java 11, 17, 21)<\/td>\n<td>Halbj\u00e4hrlich (z.B. Java 12, 13, 14&#8230;)<\/td>\n<td>Wird mit jeder Java-Version ausgeliefert (LTS und non-LTS)<\/td>\n<td>Definiert, was jede Java-Version \u201ehaben muss\u201c<\/td>\n<td>An eine bestimmte Java-Version gebunden, wird zusammen mit dem JDK ver\u00f6ffentlicht<\/td>\n<\/tr>\n<tr>\n<td>Stabilit\u00e4t<\/td>\n<td>Sehr stabil, empfohlen f\u00fcr Unternehmen und Produktion<\/td>\n<td>Experimenteller, bringt neue Features schneller<\/td>\n<td>Bietet alle Entwicklungswerkzeuge f\u00fcr Java<\/td>\n<td>Enth\u00e4lt Basis-API (Collections, Streams, IO, Concurrency usw.)<\/td>\n<td>Stabile Laufzeitumgebung f\u00fcr Anwendungen<\/td>\n<\/tr>\n<tr>\n<td>Zielgruppe<\/td>\n<td>Konzerne, Enterprise-L\u00f6sungen, langfristige Projekte<\/td>\n<td>Entwickler, Test neuer Features<\/td>\n<td>Programmierer und Entwicklerteams<\/td>\n<td>Ganze Java-Community (Standardisierung)<\/td>\n<td>Endbenutzer und Umgebungen, in denen Anwendungen nur ausgef\u00fchrt werden<\/td>\n<\/tr>\n<tr>\n<td>Risiko<\/td>\n<td>Minimal, langfristige Fixes und Sicherheitsupdates<\/td>\n<td>H\u00f6her \u2013 Feature kann in der n\u00e4chsten Version entfernt werden<\/td>\n<td>Kein zus\u00e4tzliches Risiko \u2013 an Version gebunden<\/td>\n<td>Stabilit\u00e4t &#8211; definiert die offizielle Grundlage von Java<\/td>\n<td>Kein Risiko \u2013 keine Entwickler-Tools, nur Runtime<\/td>\n<\/tr>\n<tr>\n<td>Beispiele<\/td>\n<td>Java 8, Java 11, Java 17, Java 21<\/td>\n<td>Java 9, 10, 12, 13, 14, 15, 16, 18&#8230;<\/td>\n<td>JDK 11, JDK 16, JDK 24&#8230;<\/td>\n<td>Java SE 9, SE 18, SE 25&#8230;<\/td>\n<td>JRE 8, JRE 11, JRE 17&#8230;<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>LTS-Versionen<\/strong> sind die Wahl f\u00fcr Stabilit\u00e4t und langfristige Unterst\u00fctzung. Unternehmen setzen sie in der Produktion ein, weil sie \u00fcber viele Jahre Sicherheitsupdates und Fehlerbehebungen erhalten.<\/p>\n<p><strong>Non-LTS-Versionen<\/strong> hingegen sind kurzlebig \u2013 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\u00e4chste LTS-Version gewechselt.<\/p>\n<p><strong>Das JDK (Java Development Kit)<\/strong> ist ein Werkzeugpaket, das du mit jeder Java-Version erh\u00e4ltst und das direkt f\u00fcr Entwickler gedacht ist.<br \/>\n<strong>Java SE (Standard Edition)<\/strong> definiert den grundlegenden Sprachstandard und das API, auf dem das gesamte Java-\u00d6kosystem aufbaut.<\/p>\n<ul>\n<li><strong>LTS-Versionen<\/strong> \u2192 Stabilit\u00e4t, langfristige Unterst\u00fctzung, geeignet f\u00fcr Produktion<\/li>\n<li><strong>non-LTS-Versionen<\/strong> \u2192 Kurzlebig, bringen neue Funktionen, geeignet zum Testen<\/li>\n<li><strong>JDK (Java Development Kit)<\/strong> \u2192 Werkzeuge f\u00fcr Entwickler (Compiler, Debugger, Bibliotheken)<\/li>\n<li><strong>Java SE (Standard Edition)<\/strong> \u2192 Basisstandard und API, Fundament des gesamten Java-Systems<\/li>\n<\/ul>\n<p>Wenn du dich also fragst, welche Version du w\u00e4hlen sollst:<\/p>\n<ul>\n<li>F\u00fcr ein <strong>langfristiges Projekt<\/strong> greif zu einer LTS-Version.<\/li>\n<li>F\u00fcr <strong>Experimente und schnelle Einf\u00fchrung neuer Features<\/strong> eignet sich non-LTS.<\/li>\n<\/ul>\n<h2><strong>Migration zwischen Java JDK-Versionen<\/strong><\/h2>\n<p>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.<\/p>\n<h3>Hauptschritte der Migration:<\/h3>\n<ol>\n<li><strong>Projekt-Analyse<\/strong>\n<ul>\n<li>Pr\u00fcfe, welche Bibliotheken und Frameworks du verwendest.<\/li>\n<li>\u00dcberpr\u00fcfe, ob sie mit der Zielversion von Java kompatibel sind.<\/li>\n<\/ul>\n<\/li>\n<li><strong>\u00dcberpr\u00fcfung veralteter und entfernter APIs<\/strong>\n<ul>\n<li>In neuen Versionen werden manche Funktionen als <em>deprecated <\/em> markiert und sp\u00e4ter ganz entfernt..<\/li>\n<li>Typische Beispiele: alte Sicherheitsalgorithmen, interne APIs wie sun.*.<\/li>\n<\/ul>\n<\/li>\n<li><strong>Kompatibilit\u00e4tstests<\/strong>\n<ul>\n<li>F\u00fchre bestehende Tests mit der neuen JDK-Version aus.<\/li>\n<li>Achte auf Warnungen und Fehler beim Kompilieren.<\/li>\n<\/ul>\n<\/li>\n<li><strong>Anpassung des Builds und der CI\/CD-Pipeline<\/strong>\n<ul>\n<li>Aktualisiere Build-Tools (Maven, Gradle).<\/li>\n<li>Stelle sicher, dass die CI\/CD-Pipeline auf der richtigen JDK-Version l\u00e4uft.<\/li>\n<\/ul>\n<\/li>\n<li><strong>Schrittweiser \u00dcbergang<\/strong>\n<ul>\n<li>Bei gro\u00dfen Projekten empfiehlt es sich, von LTS zu LTS zu wechseln (z. B. von 11 \u2192 17 \u2192 21).<\/li>\n<li>So vermeidest du Zwischenversionsprobleme und erh\u00e4ltst Stabilit\u00e4t.<\/li>\n<\/ul>\n<\/li>\n<li><strong>Performance- und Regressionstests<\/strong>\n<ul>\n<li>Teste die Anwendung unter Last, um m\u00f6gliche Verlangsamungen oder Memory Leaks zu erkennen.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n<p><strong>H\u00e4ufige Probleme bei der Migration:<\/strong><\/p>\n<ul>\n<li><strong>Nicht unterst\u00fctzte Bibliotheken<\/strong> \u2013 \u00e4ltere Dependencies funktionieren eventuell nicht mehr mit dem neuen JDK.<\/li>\n<li><strong>Entfernte APIs<\/strong> \u2013 wenn das Projekt interne JDK-APIs nutzt, kann das zu Fehlern f\u00fchren.<\/li>\n<li><strong>Sicherheits\u00e4nderungen<\/strong> &#8211; strengere TLS\/SSL-Einstellungen k\u00f6nnen \u00e4ltere Verbindungen blockieren.<\/li>\n<\/ul>\n<p>Am sichersten ist es, immer auf die neueste <strong>LTS-Version<\/strong> zu migrieren, die Anwendung gr\u00fcndlich zu testen und sie dann in die Produktion zu bringen. Non-LTS-Versionen sind ideal f\u00fcr Experimente, aber nicht f\u00fcr den langfristigen Betrieb von Anwendungen.<\/p>\n<p>Als n\u00e4chstes werden wir die \u00c4nderungen und Verbesserungen in jeder Java-Version im Detail besprechen.<\/p>\n<h2>Java SE 24<\/h2>\n<p>Java 24 bringt die neue Version JDK 24 mit symbolischen 24 Verbesserungen in Sprache, API, Plattformleistung, Stabilit\u00e4t und Sicherheit. Eine so umfangreiche und aufregende Ver\u00f6ffentlichung gab es schon lange nicht mehr. Also verlieren wir keine Zeit und schauen uns die Neuerungen Schritt f\u00fcr Schritt an.<\/p>\n<h3>Java JDK 24 bringt zahlreiche \u00c4nderungen und Verbesserungen<\/h3>\n<p>Die neue Version <strong>Java 24<\/strong> wurde von Oracle am 18. M\u00e4rz 2025 ver\u00f6ffentlicht. Das vollst\u00e4ndige Entwicklerpaket Java Development Kit 24 (JDK 24) f\u00fcr diese Java-Version bietet zahlreiche Verbesserungen f\u00fcr <a href=\"https:\/\/msg-life.sk\/de\/stellenangebote\/programmierer\">Programmierer<\/a>.<\/p>\n<div class=\"tip center\">\n    <div class=\"tip-wrap\">\n                             <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/msgprogramator.sk\/wp-content\/themes\/msg-programator\/assets\/svg\/recommend.svg\" alt=\"Recommend\" width=\"60\" height=\"60\">\n                    <div class=\"tip-wrap-content\">\n            <div class=\"tip-wrap-title\">\n                Wir empfehlen Ihnen\u2026            <\/div>\n            <p>Java 24 einschlie\u00dflich der Release Notes steht <a href=\"https:\/\/www.oracle.com\/in\/java\/technologies\/downloads\/\">unter diesem Link zum Download<\/a> bereit. <\/p>\n        <\/div>\n    <\/div>\n<\/div>\n\n<p>Wie auch die vorherigen Java-Versionen ist <strong>Java 24<\/strong> das Ergebnis gemeinsamer Anstrengungen vieler Mitwirkender \u2013 sowohl einzelner Personen als auch Organisationen der OpenJDK-Community. W\u00e4hrend die Anzahl der \u00c4nderungen in den JDK-Ver\u00f6ffentlichungen seit mehreren Jahren ungef\u00e4hr gleich bleibt, hat sich im letzten sechsmonatigen Zyklus das Tempo, mit dem neue Funktionen und Verbesserungen in die Produktion gelangen, deutlich beschleunigt.<\/p>\n<figure id=\"attachment_8768\" aria-describedby=\"caption-attachment-8768\" style=\"width: 1475px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-8766 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/08\/Java-clanok-fialovo-modre-1.webp\" alt=\"Entwicklung der Anzahl der neuen Funktionen in den Java JDK-Versionen 8 bis 24.\" width=\"1475\" height=\"800\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/08\/Java-clanok-fialovo-modre-1.webp 1475w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/08\/Java-clanok-fialovo-modre-1-300x163.webp 300w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/08\/Java-clanok-fialovo-modre-1-1024x555.webp 1024w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2025\/08\/Java-clanok-fialovo-modre-1-768x417.webp 768w\" sizes=\"auto, (max-width: 1475px) 100vw, 1475px\" \/><figcaption id=\"caption-attachment-8768\" class=\"wp-caption-text\">\u00dcberblick \u00fcber Java-Spracherweiterungen (JEPs) der letzten 11 Jahre (Quelle: <a href=\"https:\/\/blogs.oracle.com\/java\/post\/the-arrival-of-java-24\">Oracle<\/a>)<\/figcaption><\/figure>\n<p>Die \u00c4nderungen in <strong>JDK 24<\/strong> reichen von bedeutenden neuen Funktionen \u00fcber kleinere Verbesserungen bis hin zu routinem\u00e4\u00dfiger Wartung, Fehlerbehebungen und Dokumentationsupdates. Jede \u00c4nderung f\u00fcr ein bestimmtes Ticket wird durch einen separaten Commit im <a href=\"https:\/\/bugs.openjdk.org\/secure\/Dashboard.jspa\">JDK Bug System<\/a>-Repository repr\u00e4sentiert.<\/p>\n<div class=\"tip center\">\n    <div class=\"tip-wrap\">\n                         <svg enable-background=\"new 0 0 153 153\" viewBox=\"0 0 153 153\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"><path d=\"m76.5 0c-42.3 0-76.5 34.2-76.5 76.5s34.2 76.5 76.5 76.5 76.5-34.3 76.5-76.5-34.2-76.5-76.5-76.5zm-1.2 127.8c-6.3 0-11.4-5.1-11.4-11.4s5.1-11.4 11.4-11.4 11.4 5.1 11.4 11.4-5.2 11.4-11.4 11.4zm9.5-42.9v7.2c0 5.2-4.2 9.4-9.4 9.4s-9.3-4.2-9.3-9.4v-15.5c0-5.2 4.2-9.3 9.3-9.4h1.4c6 0 10.8-4.9 10.8-10.8 0-6-4.9-10.8-10.8-10.8-6 0-10.8 4.8-10.8 10.8v.4c0 5.2-4.2 9.3-9.3 9.3-5.2 0-9.4-4.2-9.4-9.3v-.4c0-16.2 13.2-29.4 29.5-29.4s29.5 13.2 29.5 29.5c0 13.3-8.8 24.9-21.5 28.4z\" fill=\"#1C42BE\"\/><g fill=\"#fff\"><path d=\"m86.7 116.4c0 6.3-5.1 11.4-11.4 11.4s-11.4-5.1-11.4-11.4 5.1-11.4 11.4-11.4 11.4 5.1 11.4 11.4z\"\/><path d=\"m106.3 56.5c0 13.2-8.8 24.8-21.5 28.4v7.2c0 5.2-4.2 9.4-9.4 9.4s-9.3-4.2-9.3-9.4v-15.5c0-5.2 4.2-9.3 9.3-9.4h1.4c6 0 10.8-4.9 10.8-10.8 0-6-4.9-10.8-10.8-10.8-6 0-10.8 4.8-10.8 10.8v.4c0 5.2-4.2 9.3-9.3 9.3-5.2 0-9.4-4.2-9.4-9.3v-.4c0-16.2 13.2-29.4 29.5-29.4s29.5 13.2 29.5 29.5z\"\/><\/g><\/svg>            \n                        <div class=\"tip-wrap-content\">\n            <div class=\"tip-wrap-title\">\n                Wusstest du, dass\u2026            <\/div>\n            <p>\u2026zwischen den Versionen Java 11 und Java 24 insgesamt 31 187 Probleme gel\u00f6st wurden? 22 107 (ca. 70 %) davon wurden von Oracle-Mitarbeitern, 9080 (ca. 30 %) von einzelnen Entwicklern, die entweder selbstst\u00e4ndig oder f\u00fcr andere Organisationen arbeiten, gel\u00f6st. 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. <\/p>\n        <\/div>\n    <\/div>\n<\/div>\n\n<p><strong>JDK 24<\/strong> bringt 24 Verbesserungen, die bedeutend genug sind, um eigene <a href=\"http:\/\/openjdk.java.net\/jeps\/1\">JDK Enhancement Proposals (JEPs)<\/a> zu erhalten \u2013 darunter 8 Preview-Features und 1 Incubator-Feature.<\/p>\n<h3>Sprachfunktionen in Oracle JDK 24<\/h3>\n<h4>Primitive types in patterns, instanceof und switch (Vorschau 2)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/488\">JEP 488<\/a>: Erweitert Pattern Matching, um Typmuster mit primitiven Typen in allen Kontexten zu erm\u00f6glichen, und erg\u00e4nzt die Operatoren <em>instanceof <\/em> und <em>switch <\/em> um Unterst\u00fctzung f\u00fcr alle primitiven Typen einschlie\u00dflich sicherer Tests und Konvertierungen. Das f\u00fchrt zu einer vereinheitlichten, ausdrucksst\u00e4rkeren Sprache f\u00fcr den Umgang mit Werten und Typen, ohne manuelle Typumwandlungen oder Bereichspr\u00fcfungen.<\/p>\n<h4>Flexible constructor bodies (Vorschau 3)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/492\">JEP 492<\/a>: Erlaubt das Einf\u00fcgen von normalen Anweisungen vor einem expliziten super(\u2026) oder this(\u2026)-Aufruf im Konstruktor-Rumpf. Diese Anweisungen d\u00fcrfen Felder initialisieren und Argumente validieren, aber keinen noch nicht fertiggestellten Objektzustand verwenden. Das f\u00fchrt zu einem nat\u00fcrlicheren Modell f\u00fcr Validierung und Datenvorbereitung vor der Erzeugung einer Oberklasse und macht Konstruktoren klarer und einfacher.<\/p>\n<h4>Module import declarations (Vorschau 2)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/494\">JEP 494<\/a>: F\u00fchrt eine neue Syntax <em>import module M<\/em>; ein, die alle \u00f6ffentlichen Top-Level-Klassen und -Schnittstellen importiert, die vom Modul M exportiert werden (einschlie\u00dflich transitiver Abh\u00e4ngigkeiten). Das beseitigt die Notwendigkeit mehrerer import \u2026 .*-Anweisungen und vereinfacht die Wiederverwendung modularer Bibliotheken in allen Projekttypen erheblich.<\/p>\n<h4>Simple source files and instance main methods (Vorschau 4)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/495\">JEP 495<\/a>: Bietet eine einfachere M\u00f6glichkeit, kleine Java-Programme zu erstellen: Erlaubt ausf\u00fchrbare Programme ohne eigene Klasse und ohne den Boilerplate <em>public static void main(String[] args)<\/em>. Unterst\u00fctzt 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\u00f6glicht den nahtlosen \u00dcbergang zu vollwertigen Programmen.<\/p>\n<h3>Bibliotheken in Oracle JDK 24<\/h3>\n<h4>Class\u2011file API<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/484\">JEP 484<\/a>: F\u00fchrt ein standardisiertes API (<em>java.lang.classfile<\/em>) zum Parsen, Erzeugen und Transformieren von .class-Dateien gem\u00e4\u00df der JVM-Spezifikation ein. Ziel ist es, interne ASM-Bibliotheken durch eine einheitliche, wartbare und voll spezifizierte Schnittstelle zu ersetzen.<\/p>\n<h4>Stream gatherers<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/485\">JEP 485<\/a>: Erweitert das Stream-API um die M\u00f6glichkeit, eigene intermediate Operationen (Stream::gather) zu definieren, die ma\u00dfgeschneiderte Transformationen (One-to-One, One-to-Many, Many-to-Many) mit voller Parallelisierungsunterst\u00fctzung erm\u00f6glichen. Das vereinfacht ausdrucksstarke und effiziente Datenverarbeitungspipelines.<\/p>\n<h4>Scoped values (Vorschau 4)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/487\">JEP 487<\/a>: F\u00fchrt den neuen Typ ScopedValue ein, um unver\u00e4nderliche (immutable) Daten innerhalb einer Methode, ihrer Aufrufe und neu erstellter Threads zu teilen \u2013 eine einfachere und leistungsf\u00e4higere Alternative zu ThreadLocal. Er bietet geringeren Speicher- und Zeitaufwand und ist besonders n\u00fctzlich bei virtuellen Threads.<\/p>\n<h4>Vektor-API (9. Inkubator)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/489\">JEP 489<\/a>: Bietet eine plattformneutrale, leistungsstarke Schnittstelle zur Darstellung von Vektorberechnungen, die w\u00e4hrend der Ausf\u00fchrung auf native SIMD-Befehle auf unterst\u00fctzten CPUs abgebildet werden. Dadurch k\u00f6nnen Entwickler eine bessere Leistung erzielen als mit \u00e4quivalenten Skalarberechnungen, die zunehmend in KI-Berechnungen verwendet werden.<\/p>\n<h4>Structured concurrency (Vorschau 4)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/499\">JEP 499<\/a>: Erm\u00f6glicht die Verwaltung von Gruppen zusammenh\u00e4ngender Aufgaben als eine einzige Arbeitseinheit \u00fcber eine neue API, was das Fehlermanagement, die Aufhebung und die Beobachtbarkeit in nebenl\u00e4ufigen Anwendungen vereinfacht. Dieses Konzept hilft, \u201eThread-Leaks\u201c zu vermeiden und verbessert die Zuverl\u00e4ssigkeit und Lesbarkeit des Codes.<\/p>\n<h3>Sicherheitsbibliotheken von Oracle JDK 24<\/h3>\n<h4>Key derivation function API (Vorschau)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/478\">JEP 478<\/a>: F\u00fchrt eine neue API <em>javax.crypto.KDF<\/em> zur Erzeugung und Erweiterung kryptographischer Schl\u00fcssel unter Verwendung standardisierter KDF-Algorithmen wie HKDF (RFC 5869) und Argon2 (RFC 9106) ein. Erm\u00f6glicht es Anwendungen, mehrere Schl\u00fcssel aus einem einzigen geheimen Eingabeschl\u00fcssel abzuleiten (z. B. in Hybrid Public Key Encryption oder TLS 1.3) und bietet eine Schnittstelle f\u00fcr Erweiterbarkeit durch weitere KDF-Implementierungen.<\/p>\n<h4>Quantum\u2011resistant module\u2011lattice\u2011based key encapsulation mechanism<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/496\">JEP 496<\/a>: Liefert eine Implementierung von ML-KEM, einem quantenresistenten KEM-Schema, das in NIST FIPS 203 standardisiert wurde. Erweitert KeyPairGenerator, KEM und KeyFactory um Parameters\u00e4tze ML-KEM-512, ML-KEM-768 und ML-KEM-1024, wodurch Anwendungen symmetrische Schl\u00fcssel sicher austauschen k\u00f6nnen, die gegen Angriffe zuk\u00fcnftiger Quantencomputer resistent sind.<\/p>\n<h4>Quantum\u2011resistant module\u2011lattice\u2011based digital signature algorithm<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/497\">JEP 497<\/a>: F\u00fcgt Unterst\u00fctzung f\u00fcr ML-DSA hinzu, einen quantenresistenten Algorithmus f\u00fcr digitale Signaturen (FIPS 204). Implementiert KeyPairGenerator, Signature und KeyFactory f\u00fcr drei Parameters\u00e4tze: ML-DSA-44, ML-DSA-65 und ML-DSA-87, was Authentifizierung und Datenintegrit\u00e4tspr\u00fcfung mit Widerstandsf\u00e4higkeit gegen Quantenangriffe erm\u00f6glicht.<\/p>\n<h3>Werkzeuge von Oracle JDK 24<\/h3>\n<h4>Linking run\u2011time images without JMODs<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/493\">JEP 493<\/a>: Erm\u00f6glicht es, mit dem Tool <strong>jlink <\/strong> Laufzeit-Images ohne JMOD-Dateien zu erstellen, reduziert die JDK-Installationsgr\u00f6\u00dfe um bis zu 25 % und vereinfacht die Modulverwaltung in Cloud- und Container-Umgebungen.<\/p>\n<h3>Leistungsverbesserungen zur Laufzeit in Oracle JDK 24<\/h3>\n<h4>Compact object headers (experimentell)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/450\">JEP 450<\/a>: Reduziert die Gr\u00f6\u00dfe von Java-Objekt-Headern von 96\u2013128 Bit auf 64 Bit auf 64-Bit-Plattformen, spart Speicher und verbessert die Datenlokalit\u00e4t im Cache. Aktivierung durch VM-Optionen:<br \/>\n-XX:+UnlockExperimentalVMOptions -XX:+UseCompactObjectHeaders.<\/p>\n<h4>Late barrier expansion for G1<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/475\">JEP 475<\/a>: Verschiebt die Expansion von Speicherbarrieren im G1 GC von fr\u00fchen Phasen der C2-Kompilierung in sp\u00e4tere, wodurch die Kompilierungszeit verk\u00fcrzt und die Implementierung vereinfacht wird, w\u00e4hrend die Leistung des generierten Codes erhalten bleibt.<\/p>\n<h4>Ahead\u2011of\u2011time class loading &amp; linking<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/483\">JEP 483<\/a>: Verbessert den JVM-Start, indem w\u00e4hrend einer Ausf\u00fchrung geladene und vorverkn\u00fcpfte Klassen im Cache gespeichert werden, den HotSpot beim n\u00e4chsten Start verwendet, wodurch die Startzeit verk\u00fcrzt wird.<\/p>\n<h4>ZGC: Remove the non\u2011generational mode<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/490\">JEP 490<\/a>: Entfernt den Non-Generational-Modus des Z Garbage Collectors (-XX:+ZGenerational), reduziert die Codekomplexit\u00e4t und macht den generational ZGC zum prim\u00e4ren Modus, der f\u00fcr die meisten Eins\u00e4tze besser geeignet ist.<\/p>\n<h4>Synchronize virtual threads without pinning<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/491\">JEP 491<\/a>: Verbessert die Skalierbarkeit synchronisierter Bl\u00f6cke bei der Verwendung virtueller Threads, indem bei einer Blockierung kein Plattform-Thread gehalten, sondern freigegeben wird, sodass mehr virtuelle Threads gleichzeitig bedient werden k\u00f6nnen.<\/p>\n<h3>Quellcode von Oracle JDK 24<\/h3>\n<h4>Generational Shenandoah (experimentell)<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/404\">JEP 404<\/a>: F\u00fchrt einen experimentellen generationalen Modus in den Shenandoah GC ein, der die nachhaltige Durchsatzleistung, die Belastbarkeit bei pl\u00f6tzlicher Last und die Speichernutzung verbessert, indem der Heap in Generationenbereiche aufgeteilt wird, ohne den bestehenden nicht-generationalen Modus zu beeintr\u00e4chtigen. Ziel ist es, den generationalen Shenandoah in zuk\u00fcnftigen Versionen als Standardmodus vorzubereiten.<\/p>\n<h4>Prepare to restrict the use of JNI<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/472\">JEP 472<\/a>: F\u00fchrt zur Laufzeit Warnungen bei Aufrufen von JNI und des Foreign Function &amp; Memory API ein, um Entwickler auf eine kommende Version vorzubereiten, die die implizite native Interaktion einschr\u00e4nken oder deaktivieren wird. JNI bleibt verf\u00fcgbar, jedoch mit klaren Warnungen und einheitlichem Verhalten vor dem \u00dcbergang zu strengeren Beschr\u00e4nkungen.<\/p>\n<h4>Remove the Windows 32\u2011bit x86 port<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/479\">JEP 479<\/a>: Entfernt Quellcode und Build-Skripte f\u00fcr den Windows 32-bit x86-Port (deprecated in JDK 21), wodurch alle spezifischen Pfade und Tests f\u00fcr diesen Port eliminiert werden. Nach dem Ende der Unterst\u00fctzung f\u00fcr Windows 10 32-bit (EOL Oktober 2025) wird die Build- und Testinfrastruktur des JDK vereinfacht.<\/p>\n<h4>Permanently disable the security manager<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/486\">JEP 486<\/a>: 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.<\/p>\n<h4>Warn upon use of memory\u2011access methods in sun.misc.Unsafe<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/498\">JEP 498<\/a>: 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.<\/p>\n<h4>Deprecate the 32\u2011bit x86 port for removal<\/h4>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/501\">JEP 501<\/a>: Markiert den letzten 32-bit x86-Port (Linux) als deprecated und bereitet dessen vollst\u00e4ndige Entfernung in JDK 25 vor. Nach der Entfernung bleibt f\u00fcr 32-bit-Architekturen nur der architekturunabh\u00e4ngige Zero-Port erhalten.<\/p>\n<p><strong>Quellen:<\/strong><\/p>\n<ul>\n<li>https:\/\/blogs.oracle.com\/java\/post\/the-arrival-of-java-24<\/li>\n<li>https:\/\/openjdk.org\/projects\/jdk\/24\/<\/li>\n<\/ul>\n<h2>Java SE 23<\/h2>\n<p>Java als Programmiersprache dominiert weiterhin die heutigen technologischen Trends. Auch die Ver\u00f6ffentlichung von Java 23 mit zahlreichen Verbesserungen zeigt, dass durchdachte Planung sowie festgelegte und eingehaltene Termine dazu beitragen, dass Java mit seinem \u00d6kosystem f\u00fcr viele Entwickler weltweit zur bevorzugten Plattform f\u00fcr moderne Softwareentwicklung geworden ist.<\/p>\n<p><strong>\u00dcberblick \u00fcber die Verbesserungen der Programmiersprache Java (JEPs) der letzten 10 Jahre<\/strong><\/p>\n<figure id=\"attachment_8241\" aria-describedby=\"caption-attachment-8241\" style=\"width: 975px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-8239\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2024\/10\/1.webp\" alt=\"QUELLE: inside.java\/2024\/09\/17\/jdk-23-available\/\" width=\"975\" height=\"474\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2024\/10\/1.webp 975w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2024\/10\/1-300x146.webp 300w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2024\/10\/1-768x373.webp 768w\" sizes=\"auto, (max-width: 975px) 100vw, 975px\" \/><figcaption id=\"caption-attachment-8241\" class=\"wp-caption-text\">QUELLE: inside.java\/2024\/09\/17\/jdk-23-available\/<\/figcaption><\/figure>\n<h3>Java 23 SE<\/h3>\n<p>Java 23 wurde am 17. September 2024 ver\u00f6ffentlicht. Wie bei den vorherigen Java-Releases ist Java 23 das kollektive Ergebnis von Beitr\u00e4gen, sowohl einzelner Personen als auch von Organisationen der OpenJDK-Community.<\/p>\n<p>Die Anzahl der \u00c4nderungen in den JDK-Updates ist in den letzten Jahren weitgehend konstant geblieben (im Durchschnitt etwa 10), was auf die regelm\u00e4\u00dfigen sechsmonatigen Ver\u00f6ffentlichungen zur\u00fcckzuf\u00fchren ist. Trotz der relativ kurzen Vorbereitungszeit reichen die \u00c4nderungen von neuen Sprachfunktionen \u00fcber kleine Verbesserungen der bestehenden Funktionalit\u00e4t bis hin zu Fehlerbehebungen und Dokumentationsaktualisierungen.<\/p>\n<p>Jede \u00c4nderung f\u00fcr ein bestimmtes Ticket wird durch einen separaten Commit im <a href=\"https:\/\/bugs.openjdk.org\/secure\/Dashboard.jspa\" target=\"_blank\" rel=\"nofollow noopener\">JDK Bug System<\/a>-Repository dargestellt. Interessant ist, dass zwischen den Versionen Java 11 bis Java 23 insgesamt 28.724 Probleme gel\u00f6st wurden, wobei 20.450 (ca. 71 %) von Mitarbeitern von Oracle und 8.274 (ca. 29 %) von einzelnen <a href=\"https:\/\/msg-life.sk\/de\/stellenangebote\/java-entwickler\/\" target=\"_blank\" rel=\"noopener\">Java-Programmierern<\/a>, die entweder selbstst\u00e4ndig oder f\u00fcr andere Organisationen arbeiten, stammen.<\/p>\n<h3>Primitive Typen in Mustern, instaceof und switch (Vorschau)<\/h3>\n<p>Diese \u00c4nderung (<a href=\"https:\/\/openjdk.org\/jeps\/455\">JEP 455<\/a>) beseitigt mehrere Einschr\u00e4nkungen, 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\u00f6nnen. Die M\u00f6glichkeit, dass <em><br \/>\n<strong>instanceof<\/strong><br \/>\n<\/em>-Instanzen auch Primitive akzeptieren, reduziert den Code weiter, da nun automatische bedingte Typumwandlungen unterst\u00fctzt werden \u2013 also F\u00e4lle, in denen \u00fcberpr\u00fcft werden muss, ob ein Wert f\u00fcr den Zieltyp g\u00fcltig ist.<\/p>\n<h3>Modulimport-Deklarationen (Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/476\">JEP 476<\/a> \u2013 erm\u00f6glicht 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\u00f6nnen Einsteiger Bibliotheken von Drittanbietern und grundlegende Java-Klassen verwenden, ohne lernen zu m\u00fcssen, wo sie sich in der Paket-Hierarchie befinden.<\/p>\n<h3>Implizit deklarierte Klassen und <em>main<\/em>-Methoden-Instanz (Dritte Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/477\">JEP 477<\/a> \u2013 Dies erm\u00f6glicht es Einsteigern, ihre ersten Java-Programme zu schreiben, ohne zun\u00e4chst die f\u00fcr gr\u00f6\u00dfere und komplexere Programme bestimmten Funktionen verstehen zu m\u00fcssen. Einfache Programme k\u00f6nnen vereinfachte Deklarationen verwenden und bei Bedarf problemlos um fortgeschrittene Funktionen erweitert werden. Auch erfahrene Entwickler k\u00f6nnen das kompakte Schreiben kleiner Programme genie\u00dfen.<\/p>\n<h3>Flexible Konstruktor-K\u00f6rper (zweite Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/482\">JEP 482<\/a> \u2013 Indem erlaubt wird, dass bestimmte Anweisungen in Konstruktoren vor dem expliziten Aufruf des Konstruktors, also <em>super(\u2026)<\/em> oder <em>this(\u2026)<\/em>, erscheinen d\u00fcrfen, erhalten Entwickler mehr Freiheit, das Verhalten von Konstruktoren besser auszudr\u00fccken. Die nat\u00fcrlichere Platzierung der Logik, die diese Funktion bietet, beseitigt die Notwendigkeit, Teile der Pr\u00fcf- und Initialisierungslogik in Hilfsmethoden oder Hilfskonstruktoren auszulagern. Zum Beispiel kann ein Konstruktor empfangene Argumente pr\u00fcfen, bevor er den Superklassen-Konstruktor aufruft, wodurch ein schnelles Scheitern erm\u00f6glicht und unn\u00f6tige Instanzen der Superklasse vermieden werden, wenn die Argumente ung\u00fcltig sind.<\/p>\n<h3>Class-file-API (zweite Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/466\">JEP 466<\/a> \u2013 Dieser JEP schl\u00e4gt 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\u00f6ffentlichungszyklus umgestellt hat, w\u00e4hrend Frameworks, die mit Klassendateien arbeiten, ihre Bibliotheken bei jeder Version aktualisieren m\u00fcssen, um neue Versionen schnell unterst\u00fctzen zu k\u00f6nnen. Nach ihrer Fertigstellung sollte diese Funktionalit\u00e4t das JDK selbst von seiner Abh\u00e4ngigkeit von der externen ASM-Bibliothek befreien.<\/p>\n<h3>Vector-API (achte Inkubation)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/469\">JEP 469<\/a> \u2013 erm\u00f6glicht es Java-Entwicklern, Vektorberechnungen auszudr\u00fccken, die zur Laufzeit zuverl\u00e4ssig in optimale Vektorinstruktionen auf unterst\u00fctzten CPU-Architekturen kompiliert werden, wodurch eine bessere Leistung als bei \u00e4quivalenten 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\u00fcckkehrt, h\u00f6chstens mit kleinen \u00c4nderungen, bis die erforderlichen Funktionen aus dem Projekt Valhalla verf\u00fcgbar sind.<\/p>\n<h3>Stream gatherers (zweite Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/473\">JEP 473<\/a> \u2013 verbessert die Stream-API, um benutzerdefinierte Zwischenoperationen zu unterst\u00fctzen. Das erm\u00f6glicht es Stream-Pipelines, Daten auf Weisen zu transformieren, die mit den vorhandenen eingebauten Zwischenoperationen nicht leicht erreichbar sind. Stream-Gatherer bieten f\u00fcr Zwischenoperationen eine Flexibilit\u00e4t, die Sammler (Collectors) f\u00fcr Endoperationen bieten. Diese Verbesserung f\u00fchrt f\u00fcnf eingebaute Gatherer ein.<\/p>\n<h3>Strukturierte Nebenl\u00e4ufigkeit (dritte Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/480\">JEP 480<\/a> \u2013 Strukturierte Nebenl\u00e4ufigkeit erm\u00f6glicht es Entwicklern, Gruppen zusammengeh\u00f6riger Aufgaben, die in verschiedenen Threads ausgef\u00fchrt werden, als eine einzige Arbeitseinheit zu behandeln. Dadurch wird die Fehlerbehandlung und das Abbrechen vereinfacht, die Zuverl\u00e4ssigkeit erh\u00f6ht und die Beobachtbarkeit verbessert. Diese API unterst\u00fctzt einen Stil des nebenl\u00e4ufigen Programmierens, der h\u00e4ufige Risiken im Zusammenhang mit Abbr\u00fcchen und Abschaltungen, wie Thread-Lecks und Verz\u00f6gerungen beim Abbrechen, eliminieren kann.<\/p>\n<h3>Scoped values (dritte Vorschau)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/481\">JEP 481<\/a> \u2013 erm\u00f6glicht es einer Methode, unver\u00e4nderliche Daten mit ihren Aufrufern innerhalb eines Threads sowie mit untergeordneten Threads zu teilen. Die Verwendung von Scoped Values l\u00e4sst sich leichter begr\u00fcnden 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\u00e4ufigkeit (JEP 480) verwendet werden.<\/p>\n<h3>ZGC: Standardm\u00e4\u00dfiger generationsbasierter Modus<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/474\">JEP 474<\/a> \u2013 schaltet den Standardmodus des Z Garbage Collectors (ZGC) auf den generationsbasierten Modus um. R\u00fcckmeldungen aus der Nutzung des in JDK 21 eingef\u00fchrten generationsbasierten ZGC sowie interne Tests haben best\u00e4tigt, dass dieser in den meisten Anwendungsf\u00e4llen deutlich besser funktioniert als der nicht-generationsbasierte ZGC. Dieser JEP verwirft au\u00dferdem den nicht-generationsbasierten Modus von ZGC mit dem Ziel, ihn in einer zuk\u00fcnftigen JDK-Version zu entfernen.<\/p>\n<h3>Markdown f\u00fcr Dokumentationskommentare<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/467\">JEP 467<\/a> \u2013 erm\u00f6glicht 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.<\/p>\n<h3>Vorschlag zur Entfernung der Speicherzugriffsmethoden in <em>sun.misc.unsafe<\/em><\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/471\">JEP 471<\/a> \u2013 Mit der Einf\u00fchrung der Foreign Function &amp; Memory API (JEP 454) in JDK 22 wurde eine unterst\u00fctzte API f\u00fcr den effizienten Zugriff auf externen (fremden) Speicher bereitgestellt. Daher wurde die zuk\u00fcnftige Entfernung der Methoden in <em>sun.misc.unsafe<\/em> angek\u00fcndigt, die f\u00fcr den fremden Speicherzugriff verwendet werden.<\/p>\n<p>Hier findest du die <a href=\"https:\/\/www.oracle.com\/java\/technologies\/javase\/23-relnote-issues.html\">Release Notes zu Java JDK 23<\/a>.<\/p>\n<h3>Fazit<\/h3>\n<p>Java 23 bringt eine Vielzahl von Verbesserungen, die die Arbeit der Entwickler vereinfachen und eine effizientere Nutzung der Plattform erm\u00f6glichen. Neue Funktionen, wie Sprach-, Leistungs- und Tool-Verbesserungen, best\u00e4tigen erneut, dass Java f\u00fcr viele Entwickler die bevorzugte Wahl ist.<\/p>\n<h2>Java SE 21 (LTS)<\/h2>\n<p>Die Ver\u00f6ffentlichung 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\u00f6ffentlichungstermin ist der 19. September 2023. Es ist jedoch bereits m\u00f6glich, diese Version im <strong>Early Access<\/strong> herunterzuladen und mit ersten Experimenten zu beginnen.<\/p>\n<p>Java 21 (nach Java 17) ist erneut eine Langzeit-Support-Version (LTS), was bedeutet, dass Oracle kostenlose Updates mindestens f\u00fcnf Jahre lang, also bis September 2028, und erweiterten, kostenpflichtigen Support bis September 2031 bereitstellen wird.<\/p>\n<h3>Java 21 Features, \u00c4nderungen und Verbesserungen<\/h3>\n<figure id=\"attachment_3654\" aria-describedby=\"caption-attachment-3654\" style=\"width: 550px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-1143 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/07\/pic01-550-420.webp\" alt=\"Java JDK 21 Funktionen\" width=\"550\" height=\"420\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/07\/pic01-550-420.webp 550w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/07\/pic01-550-420-300x229.webp 300w\" sizes=\"auto, (max-width: 550px) 100vw, 550px\" \/><figcaption id=\"caption-attachment-3654\" class=\"wp-caption-text\">Java JDK 21 Funktionen<\/figcaption><\/figure>\n<h3>Virtuelle Threads (virtual threads)<\/h3>\n<p><a href=\"https:\/\/openjdk.org\/jeps\/444\" target=\"_blank\" rel=\"nofollow noopener\">Virtuelle Threads<\/a> sind leichtgewichtige Threads, die das Schreiben, Warten und \u00dcberwachen von hochperformanten, nebenl\u00e4ufigen Anwendungen erheblich vereinfachen. Sie erm\u00f6glichen das Skalieren von Serveranwendungen nach dem Thread-per-Request-Prinzip bei effizienter Hardwareauslastung, die einfache Migration bestehenden Codes, der das <strong>API <\/strong> <em>lang.Thread<\/em> verwendet, auf virtuelle Threads mit minimalen \u00c4nderungen sowie einfaches Debugging und Profiling virtueller Threads mit den vorhandenen JDK-Tools.<\/p>\n<p>Virtuelle Threads wurden in JDK 19 und JDK 20 eingef\u00fchrt und werden in JDK 21 fertiggestellt. Mit JDK 21 unterst\u00fctzen virtuelle Threads nun Thread-lokale Variablen w\u00e4hrend der gesamten Laufzeit, und es ist nicht erlaubt, virtuelle Threads ohne diese Variablen zu erstellen. Die garantierte Unterst\u00fctzung von Thread-lokalen Variablen stellt sicher, dass viele bestehende Bibliotheken ohne \u00c4nderungen mit virtuellen Threads verwendet werden k\u00f6nnen.<\/p>\n<h3>Sequenzielle Kollektionen (sequenced collections)<\/h3>\n<p>Sequenzielle oder geordnete Kollektionen sind eine weitere interessante Neuerung. JDK 21 f\u00fchrt ein Design f\u00fcr geordnete Kollektionen ein und definiert Schnittstellen f\u00fcr 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\u00fcr diesen Entwurf liegt darin, dass das <a href=\"https:\/\/msgprogramator.sk\/en\/java-collections-framework\/\">Java Collection Framework<\/a> bisher keinen Typ hatte, der eine geordnete Sequenz von Elementen repr\u00e4sentiert. Es fehlte eine einheitliche Menge an Operationen f\u00fcr solche Kollektionen. Diese L\u00fccken f\u00fchrten zu Problemen und Beschwerden. Der Vorschlag definiert Schnittstellen f\u00fcr Sequenzen von Kollektionen, Mengen und Maps und integriert sie in die bestehende Hierarchie. Alle neuen Methoden haben Standardimplementierungen.<\/p>\n<h3>Datensatzmuster (record patterns)<\/h3>\n<p>Record Patterns erm\u00f6glichen die Dekonstruktion von Record-Werten. Muster und Typmuster k\u00f6nnen verschachtelt werden, was eine deklarative und kombinierbare Datenabfrage erm\u00f6glicht. Ziel ist es, das Pattern Matching auf die Destruktion von Record-Instanzen zu erweitern und verschachtelte Muster hinzuzuf\u00fcgen, um die Komposition von Datenabfragen zu erm\u00f6glichen. Diese Funktion wurde parallel zur Pattern-Matching-Funktion f\u00fcr Switch-Ausdr\u00fccke entwickelt.<\/p>\n<h3>Pattern Matching f\u00fcr Switch<\/h3>\n<p>Diese Funktion erm\u00f6glicht es dem Switch-Ausdruck bzw. der Switch-Anweisung, mehrere Muster zu testen, von denen jedes eine bestimmte Aktion ausf\u00fchrt. Dadurch wird eine sichere und pr\u00e4gnante Darstellung komplexer Datenabfragen erm\u00f6glicht. Diese Funktion wurde urspr\u00fcnglich in JDK 17 entworfen, in sp\u00e4teren Versionen weiterentwickelt und soll in JDK 21 basierend auf dem Feedback und den Erfahrungen von Java-Entwicklern abgeschlossen und angepasst werden. Die wichtigsten \u00c4nderungen gegen\u00fcber fr\u00fcheren JEP-Versionen umfassen das Entfernen von Klammern in Mustern, die Zulassung qualifizierter Enumerationskonstanten sowie die Erh\u00f6hung der Sicherheit von Switch-Ausdr\u00fccken und -Anweisungen, indem sichergestellt wird, dass alle m\u00f6glichen Eingabewerte abgedeckt sind. Ein weiteres Ziel ist es sicherzustellen, dass bestehende Switch-Schreibweisen weiterhin ohne \u00c4nderungen funktionieren und mit derselben Semantik ausgef\u00fchrt werden.<\/p>\n<h3>Zeichenkettenvorlagen (string templates)<\/h3>\n<p>Diese Funktion liegt in JDK 21 als Vorschau vor und erg\u00e4nzt bestehende String-Literale und Textbl\u00f6cke in Java, indem sie Text mit eingebetteten Ausdr\u00fccken und Prozessoren kombiniert, um spezialisierte Ergebnisse zu erzeugen. Dieses Sprachfeature und die zugeh\u00f6rige API sollen das Schreiben von Java-Programmen vereinfachen, indem sie es erm\u00f6glichen, Zeichenketten mit zur Laufzeit berechneten Werten einfach auszudr\u00fccken. Es verspricht eine bessere Lesbarkeit von Ausdr\u00fccken, erh\u00f6hte Programmsicherheit, die Beibehaltung von Flexibilit\u00e4t und eine vereinfachte Nutzung von APIs, die Zeichenketten in anderen Sprachen als Java erwarten. Die Funktion erm\u00f6glicht zudem die Entwicklung von Nicht-String-Ausdr\u00fccken, die durch die Kombination von Textliteralen und eingebetteten Ausdr\u00fccken entstehen.<\/p>\n<h3>Unbenannte Muster und Variablen (unnamed patterns and variables)<\/h3>\n<p>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\u00f6nnen initialisiert, aber nicht verwendet werden. Ziel ist es, unn\u00f6tig verschachtelte Muster zu eliminieren und ungenutzte Variablen eindeutig zu kennzeichnen.<\/p>\n<h3>Unbenannte Klassen und Instanz-Main-Methoden (unnamed classes and instance main methods)<\/h3>\n<p>Diese Funktion zielt darauf ab, das Schreiben der ersten Java-Programme zu vereinfachen, sodass Lernende nicht sofort die komplexeren Sprachkonstrukte verstehen m\u00fcssen, die f\u00fcr gr\u00f6\u00dfere Projekte gedacht sind. Sie erlaubt die Erstellung einfacher Programme, die nach und nach um fortgeschrittene Funktionen erweitert werden k\u00f6nnen.<\/p>\n<h3>Strukturierte Nebenl\u00e4ufigkeit (structured concurrency)<\/h3>\n<p>Strukturierte Nebenl\u00e4ufigkeit vereinfacht die Programmierung in einem nebenl\u00e4ufigen Umfeld durch eine API, die Gruppen verwandter Aufgaben als Arbeitseinheiten verwaltet. Dadurch wird die Fehlerbehandlung verbessert, was Zuverl\u00e4ssigkeit und Beobachtbarkeit erh\u00f6ht. Diese Funktion, die zuvor in JDK 19 und JDK 20 getestet wurde, wird nun als Vorschau-API im Paket <em>util.concurrent<\/em> bereitgestellt.<\/p>\n<h3>Scoped values<\/h3>\n<p>Die Vorschauversion dieser Funktion erm\u00f6glicht das Teilen unver\u00e4nderlicher Daten zwischen Threads und Komponenten. Scoped Values werden Thread-lokalen Variablen vorgezogen, insbesondere bei der Verwendung einer gro\u00dfen Anzahl virtueller Threads. Diese Funktion verbessert die Lesbarkeit und Robustheit des Codes.<\/p>\n<h3>Prepare to disallow the dynamic loading of agents<\/h3>\n<p>Das Verbot des dynamischen Ladens von Agenten \u2013 diese \u00c4nderung zielt darauf ab, die Integrit\u00e4t der JVM zu verbessern, indem das Laden von Agenten zur Laufzeit einer Anwendung hervorgehoben und kontrolliert wird. Ziel ist es, das Gleichgewicht zwischen Wartungs\u00e4nderungen und Codeintegrit\u00e4t zu verbessern und sicherzustellen, dass die meisten Tools von dieser \u00c4nderung nicht betroffen sind.<\/p>\n<h3>API zur Schl\u00fcsselkapselung (key encapsulation mechanism)<\/h3>\n<p>Diese Funktion erm\u00f6glicht die Nutzung von Algorithmen zur Absicherung symmetrischer Schl\u00fcssel unter Verwendung \u00f6ffentlicher Kryptographie. Ziel ist es, Anwendungen zu erm\u00f6glichen, Algorithmen wie den <em>RSA Key Encapsulation Mechanism<\/em> (RSA-KEM) und das <em>Elliptic Curve Integrated Encryption Scheme<\/em> (ECIES) in verschiedenen Protokollen und kryptografischen Schemata zu verwenden.<\/p>\n<h3>Generation ZGC<\/h3>\n<p>Diese Funktion zielt darauf ab, die Leistung von Anwendungen durch die Trennung von Generationen f\u00fcr junge und alte Objekte zu verbessern. Generational ZGC erm\u00f6glicht eine effizientere Sammlung junger Objekte und f\u00fchrt zu einem geringeren Speicherverbrauch sowie zu einer niedrigeren Belastung durch die Garbage Collection (Sammlung nicht mehr ben\u00f6tigter, allokierter Speicherbereiche).<\/p>\n<h3>Foreign function &amp; memory API<\/h3>\n<p>Erm\u00f6glicht die Interoperabilit\u00e4t von Java-Programmen mit Code und Daten au\u00dferhalb der Java-Laufzeitumgebung. Es erlaubt das Aufrufen externer Bibliotheken und den sicheren Zugriff auf Speicher, wodurch das <strong>JNI <\/strong> (<em>Java Native Interface<\/em>) ersetzt wird.<\/p>\n<h3>Vector-API (vector API)<\/h3>\n<p>Diese API erm\u00f6glicht die Durchf\u00fchrung von Berechnungen in Vektorform, was zu einer besseren Leistung im Vergleich zu skalaren Berechnungen f\u00fchrt. Das Ziel ist es, eine einfache und zuverl\u00e4ssige L\u00f6sung f\u00fcr Vektorberechnungen auf unterst\u00fctzten Architekturen bereitzustellen.<\/p>\n<h3>Deprecate the Windows 32-bit x86 port for removal<\/h3>\n<p>Diese \u00c4nderung konzentriert sich darauf, den 32-Bit-Port f\u00fcr Windows x86 in einer zuk\u00fcnftigen Version zu entfernen. Windows 10, das letzte Betriebssystem von Microsoft mit Unterst\u00fctzung f\u00fcr den 32-Bit-Modus, erreicht sein Lebenszyklusende im Oktober 2025.<\/p>\n<p>Neben diesen Funktionen wird in JDK 21 auch eine \u00c4nderung bei der Zuordnung von Netzwerkschnittstellennamen unter Windows vorbereitet. Au\u00dferdem ist eine experimentelle Funktion namens \u201ecompact object headers\u201c geplant, die die Gr\u00f6\u00dfe der Objekt-Header in der JVM verringern und somit den Speicherbedarf reduzieren soll.<\/p>\n<p>Wenn dich die neuen Funktionen von Java JDK 21 interessieren und du mehr dar\u00fcber erfahren m\u00f6chtest, empfehlen wir dir, die offizielle Website von <a href=\"https:\/\/openjdk.org\/projects\/jdk\/21\/\" target=\"_blank\" rel=\"nofollow noopener\">OpenJDK <\/a> zu besuchen.<\/p>\n<h2>Java SE 20<\/h2>\n<p>Oracle hat am 21. M\u00e4rz 2023 die Verf\u00fcgbarkeit der neuesten Version der weltweit beliebtesten Programmiersprache und Entwicklungsplattform angek\u00fcndigt. In diesem Artikel konzentrieren wir uns auf einige der bedeutendsten Neuerungen.<\/p>\n<figure id=\"attachment_3790\" aria-describedby=\"caption-attachment-3790\" style=\"width: 1200px\" class=\"wp-caption alignnone\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-922 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-news-graf-1200-800-text.webp\" alt=\"\u00dcberblick \u00fcber die Anzahl der Neuerungen, die in den verschiedenen Versionen von Java JDK ver\u00f6ffentlicht wurden, sowie die zeitlichen Abst\u00e4nde zwischen ihnen.\" width=\"1200\" height=\"800\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-news-graf-1200-800-text.webp 1200w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-news-graf-1200-800-text-300x200.webp 300w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-news-graf-1200-800-text-1024x683.webp 1024w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-news-graf-1200-800-text-768x512.webp 768w\" sizes=\"auto, (max-width: 1200px) 100vw, 1200px\" \/><figcaption id=\"caption-attachment-3790\" class=\"wp-caption-text\">\u00dcberblick \u00fcber die Anzahl der in Java JDK ver\u00f6ffentlichten Neuerungen und die zeitlichen Abst\u00e4nde zwischen ihnen. QUELLE: blogs.oracle.com<\/figcaption><\/figure>\n<p>Java SE 20 (Oracle JDK 20) bringt Tausende von Verbesserungen in den Bereichen Leistung, Stabilit\u00e4t und Sicherheit, einschlie\u00dflich Plattformverbesserungen, die Entwicklern helfen, ihre Produktivit\u00e4t zu steigern und Innovation sowie Wachstum in ihren Organisationen zu f\u00f6rdern. Seit \u00fcber 25 Jahren erm\u00f6glicht Java Entwicklern, neue Generationen robuster, skalierbarer und sicherer Anwendungen zu entwerfen und zu erstellen.<\/p>\n<p>Oracle JDK 20 ist keine Langzeit-Support-Version (LTS \u2013 long-term support), daher erh\u00e4lt es Updates nur so lange, bis es in sechs Monaten durch JDK 21 ersetzt wird.<\/p>\n<p>Die letzte LTS-Version von Java bleibt somit weiterhin Oracle JDK 17 (ver\u00f6ffentlicht am 14. September 2021). Oracle hat jedoch Pl\u00e4ne angek\u00fcndigt, den Zeitraum zwischen den LTS-Ver\u00f6ffentlichungen von drei Jahren auf zwei Jahre zu verk\u00fcrzen, sodass JDK 21 als n\u00e4chstes LTS im September 2023 geplant ist.<\/p>\n<p>Die Anzahl der \u00c4nderungen in den JDK-Versionen hat sich im Laufe der Zeit kaum ver\u00e4ndert, aber durch den sechsmonatigen Ver\u00f6ffentlichungsrhythmus hat sich die Geschwindigkeit, mit der neue Funktionen und produktionsreife Verbesserungen bereitgestellt werden, erheblich erh\u00f6ht. Anstatt zehntausende Korrekturen vorzunehmen und fast hundert JEPs (JDK Enhancement Proposals) alle paar Jahre mit gro\u00dfen Releases zu liefern, werden Verbesserungen nun in kleineren Versionen auf einem vorhersehbareren sechsmonatigen Zeitplan ver\u00f6ffentlicht. Die \u00c4nderungen reichen von bedeutenden neuen Funktionen \u00fcber kleinere Verbesserungen bis hin zu Routinewartung, Fehlerbehebungen und Dokumentationsoptimierungen. Jede \u00c4nderung wird durch einen separaten Commit und ein Issue im JDK-Bug-System repr\u00e4sentiert.<\/p>\n<div class=\"inside\"><\/div>\n<div>\n<h3>Neuerungen in Java 20 JDK<\/h3>\n<p>Java 20 JDK enth\u00e4lt sieben JEPs (JDK Enhancement Proposals), die darauf abzielen, die Produktivit\u00e4t der Entwickler zu steigern, die Sprache Java zu verbessern und die Leistung, Stabilit\u00e4t und Sicherheit der Plattform zu erh\u00f6hen. Diese Funktionen umfassen virtuelle Threads, den Entwurf der Vector-API, strukturierte Nebenl\u00e4ufigkeit, Scoped Values, die Foreign Function and Memory API, Record Patterns und Pattern Matching f\u00fcr Switch-Anweisungen und -Ausdr\u00fccke.<\/p>\n<h3><strong>Virtuelle Threads (virtual threads)<\/strong><\/h3>\n<p>Virtuelle Threads sind leichtgewichtige Threads, die den Aufwand beim Schreiben, Warten und Debuggen von leistungsstarken, nebenl\u00e4ufigen Anwendungen reduzieren. Sie sind Instanzen der Klasse <em>java.lang.Thread<\/em>, aber sie sind nicht an ein bestimmtes Betriebssystem-Thread gebunden. Wenn Code, der in einem virtuellen Thread l\u00e4uft, 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\u00fchren.<\/p>\n<p>Virtuelle Threads eignen sich f\u00fcr Aufgaben, die den gr\u00f6\u00dften Teil der Zeit blockierend verbringen, h\u00e4ufig beim Warten auf den Abschluss von Ein-\/Ausgabeoperationen. Sie sind jedoch nicht f\u00fcr langfristige, CPU-intensive Operationen gedacht.<\/p>\n<h3>Entwurf der Vector-API (vector API proposal)<\/h3>\n<p>Die Vector-API ist eine neue Funktion in Java 20 JDK, die eine API zur Darstellung von Vektorberechnungen einf\u00fchrt, die zuverl\u00e4ssig in optimale Vektorinstruktionen auf unterst\u00fctzten CPU-Architekturen kompiliert werden, um eine Leistung zu erzielen, die \u00fcber der von gleichwertigen skalaren Berechnungen liegt.<\/p>\n<p>Das Ziel ist es, eine klare und pr\u00e4gnante API bereitzustellen, die in der Lage ist, eine breite Palette von Vektorberechnungen auszudr\u00fccken, bestehend aus Sequenzen von Vektoroperationen in Schleifen, eventuell mit Kontrollfluss. Es sollte m\u00f6glich sein, Berechnungen zu formulieren, die in Bezug auf die Vektorgr\u00f6\u00dfe oder die Anzahl der Bahnen pro Vektor generisch sind, wodurch die Portabilit\u00e4t solcher Berechnungen \u00fcber verschiedene Hardwareplattformen mit unterschiedlichen Vektorgr\u00f6\u00dfen erm\u00f6glicht wird.<\/p>\n<h3>Strukturierte Nebenl\u00e4ufigkeit (structured concurrency)<\/h3>\n<p>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\u00fchrt werden, als eine Einheit der Arbeit zu behandeln. Fehlerbehandlung und Thread-Abbruch werden vereinfacht, was die Zuverl\u00e4ssigkeit verbessert und die Beobachtbarkeit erh\u00f6ht.<\/p>\n<p>Die einzige \u00c4nderung gegen\u00fcber dem Konzept in JDK 19 besteht darin, dass die Klasse StructuredTaskScope aktualisiert wurde, um die Vererbung von Scoped Values durch Threads zu unterst\u00fctzen, die innerhalb des Task-Scopes erstellt wurden.<\/p>\n<h3>Scoped values<\/h3>\n<p>Scoped Values sind eine Neuerung in Java 20 JDK, die es Entwicklern erm\u00f6glicht, unver\u00e4nderliche Daten innerhalb und zwischen Threads zu speichern und zu teilen. Diese neue API wird in Java 20 JDK als Inkubationsfunktion gem\u00e4\u00df JEP 439 eingef\u00fchrt.<\/p>\n<p>In Java 20 JDK wird die neue Klasse jdk.incubator.concurrent.ScopedValue &lt;T&gt; eingef\u00fchrt, die einen begrenzten Wert als Schl\u00fcssel-Wert-Paar darstellt. Grunds\u00e4tzlich ist ein begrenzter Wert ein Wert, der nur einmal gesetzt wird und f\u00fcr eine begrenzte Zeit in einem Thread zum Lesen verf\u00fcgbar ist. Begrenzte Werte erm\u00f6glichen die gemeinsame Nutzung von Daten, ohne Methodenargumente zu verwenden.<\/p>\n<h3>API f\u00fcr fremde Funktionen und Speicher (foreign function and memory API)<\/h3>\n<p>Diese neue Funktion in Java 20 JDK erm\u00f6glicht es Java-Programmen, mit Code und Daten au\u00dferhalb der Java Runtime zu interagieren. Durch effizientes Aufrufen fremder Funktionen (Code au\u00dferhalb der Java Virtual Machine [JVM]) und sicheren Zugriff auf fremden Speicher (nicht von der JVM verwalteter Speicher) k\u00f6nnen Java-Programme native Bibliotheken aufrufen und native Daten verarbeiten, ohne das Java Native Interface verwenden zu m\u00fcssen. Das erh\u00f6ht Benutzerfreundlichkeit, Leistung und Sicherheit.<\/p>\n<h3>Muster von Aufzeichnungen (record patterns)<\/h3>\n<p>Diese Verbesserung erweitert die Java-Sprache, indem sie es erm\u00f6glicht, 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\u00e4t der Entwickler zu steigern, indem es ihnen erlaubt, Pattern Matching f\u00fcr komplexere Datenabfragen zu nutzen.<\/p>\n<h3>Mustervergleich f\u00fcr Switch-Anweisungen und -Ausdr\u00fccke (pattern matching for switch statements and expressions)<\/h3>\n<p>Erm\u00f6glicht Entwicklern, Patterns in Switch-Bedingungen zu verwenden. Im Vergleich zur Verwendung von Konstanten bietet dies gr\u00f6\u00dfere Flexibilit\u00e4t und Ausdrucksst\u00e4rke.<\/p>\n<h3>Fazit<\/h3>\n<p>Die neue Version Java SE 20 JDK bringt neben Fehlerbehebungen auch sieben JEPs zur Verbesserung der Produktivit\u00e4t der Entwickler, zur Weiterentwicklung der Sprache Java und zur Steigerung der Leistung, Stabilit\u00e4t und Sicherheit der Plattform.<\/p>\n<p>Du kannst sie hier herunterladen: <a href=\"https:\/\/www.oracle.com\/java\/technologies\/javase\/jdk20-archive-downloads.html\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 20 JDK Download<\/a>.<\/p>\n<h2>Java SE 17 (LTS)<\/h2>\n<p>Bis M\u00e4rz 2022 ist die neueste Version <strong>Java 17<\/strong>, die eine neue Rendering-Pipeline f\u00fcr macOS-Systeme, die Unterst\u00fctzung f\u00fcr den neuesten Apple M1-Chip und die Unterst\u00fctzung f\u00fcr sealed classes eingef\u00fchrt hat. Au\u00dferdem gibt es sprachliche Verbesserungen sowie die Entfernung der Komplexit\u00e4t von <em>ahead-of-time<\/em> und <em>just-in-time<\/em>.<\/p>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-17-new-features\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 17<\/a><\/p>\n<h2>Java SE 16<\/h2>\n<p>Version 16 wurde im M\u00e4rz 2021 ver\u00f6ffentlicht und brachte eine bedeutende \u00c4nderung mit sich \u2013 <strong>die Migration von OpenJDK zu Git<\/strong>. Der Quellcode von OpenJDK wurde von Mercurial zu Git migriert. Der Grund daf\u00fcr war die Gr\u00f6\u00dfe der Metadatendateien, bessere Werkzeuge und das Hosting.<\/p>\n<p>Quelle: <a href=\"https:\/\/mkyong.com\/java\/what-is-new-in-java-16\/\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 16<\/a><\/p>\n<h2>Java SE 15<\/h2>\n<p>Java SE 15 wurde im September 2020 ver\u00f6ffentlicht und brachte <strong>drei gro\u00dfe Aktualisierungen mit sich:<\/strong><\/p>\n<h3>Textbl\u00f6cke als Standard<\/h3>\n<p>Textbl\u00f6cke, die in Java 13 als Vorschau eingef\u00fchrt wurden, sind nun ein <strong>Sprachstandard <\/strong> geworden.<\/p>\n<h3>Sealed-Klassen<\/h3>\n<p>Die Zugriffsmodifikatoren <em>public<\/em>, <em>protected <\/em> und <em>private <\/em> bieten nur eine sehr grobe Kontrolle. Mit den Schl\u00fcsselw\u00f6rtern <em>sealed<\/em>, <em>non-sealed<\/em> und <em>permits <\/em> kann der Programmierer die <strong>Vererbungshierarchie<\/strong> gezielt steuern. Ziel der <em>sealed <\/em> Klassen ist es, einzelnen Klassen zu erm\u00f6glichen zu deklarieren, welche Typen als <strong>Subtypen <\/strong> verwendet werden d\u00fcrfen. Dies gilt auch f\u00fcr Schnittstellen und die Festlegung, welche Typen sie implementieren d\u00fcrfen.<\/p>\n<figure id=\"attachment_3866\" aria-describedby=\"caption-attachment-3866\" style=\"width: 478px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-908\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/sealed-triedy-v-java-15.jpg\" alt=\"Code \u2013 Vererbungshierarchie mit versiegelte (sealed) Klassen\" width=\"478\" height=\"170\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/sealed-triedy-v-java-15.jpg 478w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/sealed-triedy-v-java-15-300x107.jpg 300w\" sizes=\"auto, (max-width: 478px) 100vw, 478px\" \/><figcaption id=\"caption-attachment-3866\" class=\"wp-caption-text\">Versiegelte (sealed) Klassen erm\u00f6glichen die Deklaration von Typen, die in jeder Klasse als Subtypen definiert werden k\u00f6nnen.<\/figcaption><\/figure>\n<p>In diesem Beispiel haben wir eine <strong>abstrakte Klasse namens Person<\/strong> deklariert. Gleichzeitig haben wir angegeben, dass nur die Klassen <strong>Employee <\/strong> und <strong>Manager <\/strong> sie erweitern d\u00fcrfen. Die Erweiterung einer <em>sealed<\/em>-Klasse erfolgt wie bisher in Java mit dem Schl\u00fcsselwort <em>extends<\/em>:<\/p>\n<figure id=\"attachment_3869\" aria-describedby=\"caption-attachment-3869\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-909\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/rozsirenie-sealed-triedy-v-java-15.jpg\" alt=\"Code \u2013 Versiegelte Klassenerweiterung in Java SE 15\" width=\"602\" height=\"169\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/rozsirenie-sealed-triedy-v-java-15.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/rozsirenie-sealed-triedy-v-java-15-300x84.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3869\" class=\"wp-caption-text\">Verwende extends, um versiegelte (sealed) Klassen in der aktuellen Version von Java und in SE 15 zu erweitern.<\/figcaption><\/figure>\n<p>&nbsp;<\/p>\n<p>Jede Klasse, die eine <em>sealed<\/em>-Klasse erweitert, muss selbst als <em>sealed<\/em>, <em>non-sealed<\/em> oder <em>final <\/em> deklariert werden. Das stellt sicher, dass die Klassenhierarchie <strong>abgeschlossen bleibt<\/strong> und der Compiler sie vollst\u00e4ndig kennt.<\/p>\n<h3>Verborgene Klassen<\/h3>\n<p>Das Ziel der verborgenen Klassen ist es, Klassen zu erstellen, die <strong>nicht sichtbar sind<\/strong>. Das bedeutet, dass sie nicht von anderen Klassen verkn\u00fcpft oder durch Reflexion entdeckt werden k\u00f6nnen. Solche Klassen haben in der Regel einen kurzen Lebenszyklus, daher sind sie in erster Linie auf Effizienz ausgelegt. Sie sind besonders n\u00fctzlich f\u00fcr Entwickler, die mit der JVM arbeiten.<\/p>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-15-new\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 15<\/a><\/p>\n<h2>Java SE 14<\/h2>\n<p>Im M\u00e4rz 2020 wurde Java SE 14 ver\u00f6ffentlicht und brachte <strong>vier bedeutende Verbesserungen:<\/strong><\/p>\n<h3>Switch als Standard<\/h3>\n<p>Der <em>switch<\/em>-Ausdruck, der in Java 12 als Vorschau eingef\u00fchrt und in Version 13 verbessert wurde, <strong>ist nun ein Sprachstandard geworden<\/strong>.<\/p>\n<figure id=\"attachment_3854\" aria-describedby=\"caption-attachment-3854\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-904\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/switch-vo-verzii-java-14.jpg\" alt=\"Code \u2013 Switch als Sprachstandard in Java SE 14\" width=\"602\" height=\"101\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/switch-vo-verzii-java-14.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/switch-vo-verzii-java-14-300x50.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3854\" class=\"wp-caption-text\">Java SE 14 hat den urspr\u00fcnglichen Switch-Ausdruck zum Sprachstandard in der Programmierung gemacht.<\/figcaption><\/figure>\n<h3>Verbesserung der NullPointerException<\/h3>\n<p>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 <strong>null <\/strong> war. In der neuen Version ist jedoch alles anders. Die Funktion wurde erweitert, und Programmierer erfahren nun endlich, welche Variable diese Ausnahme verursacht hat.<\/p>\n<h3>Java Records<\/h3>\n<p>Records wurden eingef\u00fchrt, um wiederkehrenden Standardcode in POJO-Datenmodellen zu reduzieren. Sie vereinfachen die t\u00e4gliche Entwicklung, erh\u00f6hen die Effizienz und <strong>minimieren das Risiko menschlicher Fehler<\/strong> erheblich. Zum Beispiel kann ein Datenmodell f\u00fcr einen Benutzer mit ID und Passwort einfach wie folgt definiert werden:<\/p>\n<figure id=\"attachment_3857\" aria-describedby=\"caption-attachment-3857\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-905\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/zaznamy-v-java-14.jpg\" alt=\"Code \u2013 Neue Records-Funktion in Java SE 14\" width=\"602\" height=\"51\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/zaznamy-v-java-14.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/zaznamy-v-java-14-300x25.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3857\" class=\"wp-caption-text\">Mit Java 14 wurden POJO-Datens\u00e4tze eingef\u00fchrt, um den sich wiederholenden Standardcode in Datenmodellen zu reduzieren.<\/figcaption><\/figure>\n<p>In diesem Fall wurde auch das neue Schl\u00fcsselwort <em>record <\/em> verwendet, das automatisch Konstruktor-, Getter-, equals-, hashCode- und toString-Methoden hinzuf\u00fcgt.<\/p>\n<h3>Pattern Matching f\u00fcr instanceof<\/h3>\n<p>Version 14 f\u00fchrte das Mustervergleichs-Feature ein, <strong>um den Code zu vereinfachen<\/strong>. Ohne die neue Funktion w\u00fcrde der Code so aussehen:<\/p>\n<figure id=\"attachment_3860\" aria-describedby=\"caption-attachment-3860\" style=\"width: 412px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-906\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-funkcie-instanceof-v-java-14.jpg\" alt=\"Code \u2013 Mustervergleich mit der Funktion instanceof in Java 14\" width=\"412\" height=\"166\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-funkcie-instanceof-v-java-14.jpg 412w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-funkcie-instanceof-v-java-14-300x121.jpg 300w\" sizes=\"auto, (max-width: 412px) 100vw, 412px\" \/><figcaption id=\"caption-attachment-3860\" class=\"wp-caption-text\">Die alte Schreibweise der instanceof-Funktion zum Vergleich von Mustern war kompliziert.<\/figcaption><\/figure>\n<p>Dank der neuen Java-Version sieht der Code jedoch viel <strong>einfacher und k\u00fcrzer<\/strong> aus:<\/p>\n<figure id=\"attachment_3863\" aria-describedby=\"caption-attachment-3863\" style=\"width: 432px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-907\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-funkcie-instanceof-v-java-14.jpg\" alt=\"Code \u2013 Verbesserte instanceof-Funktion in Java 14\" width=\"432\" height=\"140\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-funkcie-instanceof-v-java-14.jpg 432w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-funkcie-instanceof-v-java-14-300x97.jpg 300w\" sizes=\"auto, (max-width: 432px) 100vw, 432px\" \/><figcaption id=\"caption-attachment-3863\" class=\"wp-caption-text\">Eine neue Funktion von Java 14 hat das Schreiben des instanceof-Ausdrucks vereinfacht.<\/figcaption><\/figure>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-14-new-features\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 14<\/a><\/p>\n<h2>Java SE 13<\/h2>\n<p>Java 13 wurde im September 2019 ver\u00f6ffentlicht. Das Update brachte <strong>zwei Hauptverbesserungen mit sich<\/strong>:<\/p>\n<h3>Textbl\u00f6cke<\/h3>\n<p>Die neue Funktion der Textbl\u00f6cke erm\u00f6glichte es Entwicklern, <strong>mehrzeilige Texte leichter zu lesen<\/strong>. Sie verwendet drei Anf\u00fchrungszeichen, \u00e4hnlich wie Python und Groovy.<\/p>\n<figure id=\"attachment_3845\" aria-describedby=\"caption-attachment-3845\" style=\"width: 500px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-901\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/textove-bloky-v-java-13.jpg\" alt=\"Code \u2013 Neue Textblockfunktion in Java SE 13\" width=\"500\" height=\"196\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/textove-bloky-v-java-13.jpg 500w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/textove-bloky-v-java-13-300x118.jpg 300w\" sizes=\"auto, (max-width: 500px) 100vw, 500px\" \/><figcaption id=\"caption-attachment-3845\" class=\"wp-caption-text\">Java 13 f\u00fchrt eine neue Textblockfunktion ein, die wie Python und Groovy drei Anf\u00fchrungszeichen verwendet.<\/figcaption><\/figure>\n<p>Dar\u00fcber hinaus stehen dir alle Funktionen der Klasse <strong>String <\/strong> zur Verf\u00fcgung.<\/p>\n<figure id=\"attachment_3848\" aria-describedby=\"caption-attachment-3848\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-902\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/funkcie-string-v-java-13.jpg\" alt=\"Code \u2013 Funktionen der Klasse String in Java SE 13\" width=\"602\" height=\"144\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/funkcie-string-v-java-13.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/funkcie-string-v-java-13-300x72.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3848\" class=\"wp-caption-text\">In Java SE 13 stehen dir auch alle Funktionen der String-Klasse zur Verf\u00fcgung.<\/figcaption><\/figure>\n<h3>Verbesserungen des switch-Ausdrucks<\/h3>\n<p>Java 13 verbessert den <em>switch<\/em>-Ausdruck aus Version 12 mit dem Schl\u00fcsselwort <em>yield<\/em>. Mit yield k\u00f6nnen Werte aus einem <strong>switch-Ausdruck zur\u00fcckgegeben werden<\/strong>.<\/p>\n<figure id=\"attachment_3851\" aria-describedby=\"caption-attachment-3851\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-903 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/vylepsenia-vyrazu-switch-v-java-13.jpg\" alt=\"Code \u2013 Verbesserter switch-Ausdruck von Version 12 in Java SE 13\" width=\"602\" height=\"355\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/vylepsenia-vyrazu-switch-v-java-13.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/vylepsenia-vyrazu-switch-v-java-13-300x177.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3851\" class=\"wp-caption-text\">Java SE 13 bietet eine verbesserte Version des Switch-Ausdrucks aus Version 12 an.<\/figcaption><\/figure>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-13-new-features\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 13<\/a><\/p>\n<h2>Java SE 12<\/h2>\n<p>Version 12 wurde im M\u00e4rz 2019 ver\u00f6ffentlicht und brachte nur eine wesentliche Verbesserung mit sich. Diese war die alternative Schreibweise des <em>switch<\/em>-Ausdrucks. Das folgende Beispiel vergleicht die <strong>alte und die neue Schreibweise<\/strong> des <em>switch<\/em>-Ausdrucks. Der Code unterscheidet zwischen Arbeits- und Wochenendtagen.<\/p>\n<figure id=\"attachment_3839\" aria-describedby=\"caption-attachment-3839\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-899\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-switch-v-java-12.jpg\" alt=\"Code \u2013 alter Switch-Ausdruck in Java SE 12\" width=\"602\" height=\"377\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-switch-v-java-12.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/stary-zapis-switch-v-java-12-300x188.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3839\" class=\"wp-caption-text\">Java 12 hat den alten switch-Ausdruck verbessert.<\/figcaption><\/figure>\n<figure id=\"attachment_3842\" aria-describedby=\"caption-attachment-3842\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-900\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-vyrazu-switch-v-java-12.jpg\" alt=\"Code \u2013 alternative Schreibweise des switch-Ausdrucks in Java 12\" width=\"602\" height=\"92\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-vyrazu-switch-v-java-12.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/novy-zapis-vyrazu-switch-v-java-12-300x46.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3842\" class=\"wp-caption-text\">Java SE 12 hat eine neue alternative Syntax f\u00fcr den Switch-Ausdruck eingef\u00fchrt.<\/figcaption><\/figure>\n<p>Der Code in der neuen Schreibweise sieht viel <strong>sauberer und k\u00fcrzer<\/strong> aus. Die neue Form von <em>switch <\/em> entfernt au\u00dferdem die Notwendigkeit des Schl\u00fcsselworts <em>break<\/em>. 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 <em>switch<\/em>-Anweisung zugewiesen werden kann.<\/p>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-12-new-features\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 12<\/a><\/p>\n<h2>Java SE 11 (LTS)<\/h2>\n<p>Java 11 war laut der <a href=\"https:\/\/snyk.io\/jvm-ecosystem-report-2021\/\" target=\"_blank\" rel=\"nofollow noopener\">j\u00e4hrlichen Umfrage des Unternehmens Snyk<\/a> die am h\u00e4ufigsten verwendete Version im Jahr 2021. Sie wurde von bis zu <strong>61,5 % der Befragten<\/strong> genutzt. Nur 12 % aktualisierten die Sprache auf die neueste Version, die zum Zeitpunkt der Umfrage Java 15 war.<\/p>\n<p>Interessant waren auch die Antworten auf die Frage, warum die Menschen nicht auf eine neuere Version umgestiegen sind. Die Mehrheit war sich einig, dass <strong>sie nicht in der Lage oder nicht bereit ist<\/strong>, Java alle sechs Monate zu migrieren. Andere, etwa 51 %, gaben an, dass sie keine \u00c4nderungen ben\u00f6tigen, da ihre aktuelle Umgebung gut funktioniert.<\/p>\n<p><strong>Zu den weiteren Gr\u00fcnden<\/strong>, warum die Teilnehmer der Umfrage bei \u00e4lteren Versionen bleiben, geh\u00f6ren:<\/p>\n<ul>\n<li>hohe Migrationskosten,<\/li>\n<li>mangelnde Bereitschaft der Kunden zur Migration,<\/li>\n<li>keine besonderen Verbesserungen in der neuen Version,<\/li>\n<li>Anwendungsserver oder Bibliotheken unterst\u00fctzen die neuesten Versionen nicht.<\/li>\n<\/ul>\n<p>Aus der Umfrage von 2020 ging au\u00dferdem hervor, dass die Strategie der meisten Entwickler (55 %) darin besteht, bei den <strong>langfristigen Versionen<\/strong> zu bleiben. Dennoch gaben bis zu 22 % der Befragten an, dass sie erst entscheiden wollen, ob sie ein Upgrade durchf\u00fchren oder nicht. Sie m\u00f6chten herausfinden, ob die neu eingef\u00fchrten Funktionen wichtig genug sind, um eine Migration zu rechtfertigen.<\/p>\n<p>Java SE 11 wurde sechs Monate nach Version 10 ver\u00f6ffentlicht, also im September 2018. Es brachte <strong>zwei wesentliche \u00c4nderungen<\/strong>:<\/p>\n<h3>Ausf\u00fchren von Java-Dateien<\/h3>\n<p>Eine wichtige \u00c4nderung in dieser Version ist, dass der Programmierer die <em>Java<\/em>-Quellcodedateien nicht mehr explizit mit dem Befehl <em>javac <\/em> kompilieren muss.<\/p>\n<figure id=\"attachment_3830\" aria-describedby=\"caption-attachment-3830\" style=\"width: 334px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-896 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/spustanie-suborov-java.jpg\" alt=\"Code zur Ausf\u00fchrung von Java-Dateien ohne Kompilierung der Quelldateien\" width=\"334\" height=\"110\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/spustanie-suborov-java.jpg 334w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/spustanie-suborov-java-300x99.jpg 300w\" sizes=\"auto, (max-width: 334px) 100vw, 334px\" \/><figcaption id=\"caption-attachment-3830\" class=\"wp-caption-text\">In der Version Java 11 muss man die Java-Quellcodedateien nicht mehr explizit mit dem Befehl javac kompilieren.<\/figcaption><\/figure>\n<p>Stattdessen kannst du die Datei <strong>direkt <\/strong> mit dem Befehl <em>java <\/em> ausf\u00fchren.<\/p>\n<figure id=\"attachment_3833\" aria-describedby=\"caption-attachment-3833\" style=\"width: 300px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-897\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/priame-spustanie-suborov-java.jpg\" alt=\"Direktes Ausf\u00fchren von Java-Dateien in SE 11\" width=\"300\" height=\"78\" \/><figcaption id=\"caption-attachment-3833\" class=\"wp-caption-text\">Direktes Ausf\u00fchren von Java-Dateien in Version SE 11.<\/figcaption><\/figure>\n<h3>Verwendung der Syntax lokaler Variablen<\/h3>\n<p>Java 11 unterst\u00fctzt die Verwendung der <strong>Syntax lokaler Variablen<\/strong> in <em>Lambda<\/em>-Parametern. Diese Funktion kann verwendet werden, um Modifikatoren auf lokale Variablen anzuwenden, zum Beispiel zur Definition einer Annotation.<\/p>\n<figure id=\"attachment_3836\" aria-describedby=\"caption-attachment-3836\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-898\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-11-syntax-lokalnych-premennych.jpg\" alt=\"Code \u2013 Verwendung der Syntax f\u00fcr lokale Variablen in Java SE 11\" width=\"602\" height=\"140\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-11-syntax-lokalnych-premennych.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-11-syntax-lokalnych-premennych-300x70.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3836\" class=\"wp-caption-text\">Java SE 11 erlaubt die Verwendung der Syntax f\u00fcr lokale Variablen in Lambda-Parametern.<\/figcaption><\/figure>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-11-new-features\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 11<\/a><\/p>\n<h2>Java SE 10<\/h2>\n<p>Java SE 10 wurde im M\u00e4rz 2018 von Oracle ver\u00f6ffentlicht. F\u00fcr Entwickler brachte es <strong>zwei wichtige \u00c4nderungen<\/strong>:<\/p>\n<h3>OpenJDK<\/h3>\n<p>Um die Java-Community offener zu gestalten, begann Oracle damit, die OpenJDK-Bin\u00e4rdateien als prim\u00e4res JDK der Zukunft zu bewerben. Das Problem ist jedoch, dass du f\u00fcr erweiterte Unterst\u00fctzung \u00e4lterer Java-Versionen <strong>bezahlen <\/strong> musst.<\/p>\n<h3>Variable var<\/h3>\n<p>Die Variable <strong>var <\/strong> ist nichts Neues, da sie auch in anderen Programmiersprachen existiert. Ihr Hauptvorteil ist, dass sie die Ausdrucksst\u00e4rke der Sprache verringert. In der Praxis bedeutet das, dass du mit ihr lange Objektnamen oder das doppelte Schreiben desselben Namens vermeiden kannst.<\/p>\n<p>Programmierer k\u00f6nnten sich jedoch fragen, was der Unterschied zwischen <strong>var und Object<\/strong> ist. Das Schl\u00fcsselwort 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 <strong>Kompilierungsfehler<\/strong>.<\/p>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/java-10-overview\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 10<\/a><\/p>\n<h2>Java SE 9<\/h2>\n<p>Java SE 9 wurde im September 2017 ver\u00f6ffentlicht und brachte mehrere \u00c4nderungen mit sich. Nicht alle waren jedoch bedeutend oder wichtig. Hier sind <strong>die drei wichtigsten<\/strong>:<\/p>\n<h3>Modularit\u00e4t \u2013 <strong>Jigsaw Project<\/strong><\/h3>\n<p>Die bedeutendste \u00c4nderung in Java 9 war das Modulsystem, das als <strong>Jigsaw Project<\/strong> bezeichnet wurde. Ein Modul ist eine Gruppe von Code mit bestimmten Eigenschaften. Die Modulfunktion teilt die Programmiersprache in kleinere Module, um Folgendes zu bieten:<\/p>\n<ul>\n<li>Abschottung,<\/li>\n<li>Reduzierung von Versionskonflikten,<\/li>\n<li>Hinzuf\u00fcgen von Kapselung,<\/li>\n<li>h\u00f6here Sicherheit,<\/li>\n<li>bessere Leistung,<\/li>\n<li>angepasste JDK-Laufzeit mit kleinerer Gr\u00f6\u00dfe.<\/li>\n<\/ul>\n<p>Um ein neues Modul zu erstellen, ben\u00f6tigst du die Datei <em>module-info.java<\/em> in deinem <em>src.main.java<\/em>-Verzeichnis. Darin kannst du deine Modulanforderungen definieren.<\/p>\n<h3>Private Methoden in Java-Schnittstellen<\/h3>\n<p>Eine weitere Funktion von Java 9 erm\u00f6glicht es, <strong>private und statische Methoden<\/strong> in Schnittstellen zu schreiben, um \u00fcberfl\u00fcssigen Code zu vermeiden.<\/p>\n<figure id=\"attachment_3821\" aria-describedby=\"caption-attachment-3821\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-893 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-privatne-staticke-metody.jpg\" alt=\"Code f\u00fcr private und statische Methoden in Java 9\" width=\"602\" height=\"337\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-privatne-staticke-metody.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-privatne-staticke-metody-300x168.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3821\" class=\"wp-caption-text\">Die Version Java 9 enth\u00e4lt die M\u00f6glichkeit, private und statische Methoden in Interfaces zu definieren.<\/figcaption><\/figure>\n<h3>Java-Kommandozeilenwerkzeug JShell<\/h3>\n<p>Oracle hat ein neues REPL-Tool namens <strong>JShell <\/strong> entwickelt. REPL steht f\u00fcr Read \u2013 Evaluate \u2013 Print \u2013 Loop. Wie der Name schon sagt, dient es dazu, Befehle auszuf\u00fchren, Variablen, Klassen und Methoden zu erstellen und sie schnell zu testen. Es ist gro\u00dfartig zum Testen kleiner Codeausschnitte, die sonst die Erstellung einer neuen Klasse mit einer main-Methode erfordern w\u00fcrden.<\/p>\n<p>JShell befindet sich im Verzeichnis <em>&lt;JAVA_HOME&gt;\/<\/em>bin, und du kannst es starten, indem du im Kommandozeilenfenster <em>jshell <\/em> eingibst und sofort mit dem Schreiben von Code beginnst.<\/p>\n<figure id=\"attachment_3824\" aria-describedby=\"caption-attachment-3824\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-894 size-full\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-jshell-nastroj-prikazoveho-riadku.jpg\" alt=\"JShell-Befehlszeilencode in Java SE 9\" width=\"602\" height=\"113\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-jshell-nastroj-prikazoveho-riadku.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/java-9-jshell-nastroj-prikazoveho-riadku-300x56.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3824\" class=\"wp-caption-text\">Das Java-Kommandozeilenwerkzeug JShell ist hervorragend geeignet, um kleine Codeausschnitte zu testen.<\/figcaption><\/figure>\n<p>Die interaktive Java-<em>JShell <\/em> wird mit einer Verlaufshistorie und <strong>automatischer Vervollst\u00e4ndigung<\/strong> geliefert. Sie bietet au\u00dferdem Funktionen wie das Speichern und Laden aus Dateien sowie einzelner oder mehrerer Codezeilen:<\/p>\n<figure id=\"attachment_3827\" aria-describedby=\"caption-attachment-3827\" style=\"width: 602px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" class=\"size-full wp-image-895\" src=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/Java-9-jshell-funkcie-nastroja.jpg\" alt=\"Autovervollst\u00e4ndigung und Historie der interaktiven Java JShell\" width=\"602\" height=\"107\" srcset=\"https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/Java-9-jshell-funkcie-nastroja.jpg 602w, https:\/\/msgprogramator.sk\/wp-content\/uploads\/2023\/05\/Java-9-jshell-funkcie-nastroja-300x53.jpg 300w\" sizes=\"auto, (max-width: 602px) 100vw, 602px\" \/><figcaption id=\"caption-attachment-3827\" class=\"wp-caption-text\">Ein neues REPL-Tool namens JShell erm\u00f6glicht das Speichern und Laden von Dateien und Codezeilen.<\/figcaption><\/figure>\n<p>Quelle: <a href=\"https:\/\/www.baeldung.com\/new-java-9\" target=\"_blank\" rel=\"nofollow noopener\">Java SE 9<\/a><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>Erl\u00e4uterung der Unterschiede zwischen Java JDK, LTS und SE, Java 24 News und Migrationstipps.<\/p>\n","protected":false},"author":14,"featured_media":9141,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[62],"tags":[],"class_list":["post-9160","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/9160","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/users\/14"}],"replies":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/comments?post=9160"}],"version-history":[{"count":8,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/9160\/revisions"}],"predecessor-version":[{"id":9755,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/posts\/9160\/revisions\/9755"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/media\/9141"}],"wp:attachment":[{"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/media?parent=9160"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/categories?post=9160"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/msgprogramator.sk\/de\/wp-json\/wp\/v2\/tags?post=9160"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}