Was hat sich in Java-Versionen geändert?

Javas Reise durch die Zeit

Java gibt es seit über zwei Jahrzehnten und unterstützt robuste Anwendungen in allen Branchen. Sie gilt seit jeher als eine der beliebtesten Programmiersprachen für die Erstellung von Unternehmensanwendungen. Mit der Veröffentlichung von Java 23 und dem Ende der Unterstützung für Java 11 erfordert die moderne Entwicklung nun Java 17 als Basis oder neuere Versionen.

Zwischen Java 17 und 23 hat sich viel weiterentwickelt. Was hat sich also geändert? Wir werden den Weg untersuchen, den Java zurückgelegt hat, um diesen Reifegrad zu erreichen.

Dieser Artikel befasst sich mit der Entwicklung von Java, der Geschichte seiner Versionen und den neuesten Updates. Wenn Sie neugierig auf die neuesten Funktionen in Java sind und wissen möchten, wie es die Zukunft der Entwicklung prägt, lesen Sie weiter.

Allgemeine Begriffe, die in Java-Versionen verwendet werden

1. JVM (Java Virtual Machine)
JVM ist plattformabhängig und führt den vom Java-Compiler generierten Bytecode aus. Es stellt die Laufzeitumgebung für die Ausführung von Anwendungen bereit. JVM verwaltet den Speicher, die Register und den Garbage-Collection-Heap.

2. JRE (Java Runtime Environment)
JRE stellt die Umgebung zum Ausführen von Java-Programmen bereit. Es umfasst die JVM- und Java-Klassenbibliotheken. Im Wesentlichen handelt es sich um ein Paket von Tools, die zum Ausführen von Java-Code erforderlich sind.

3. JDK (Java Development Kit)
JDK ist ein vollständiges Toolkit zur Entwicklung von Java-Anwendungen. Es umfasst JRE, Compiler, einen Debugger und Tools wie Javadoc. Es ermöglicht Entwicklern, Java-Code zu erstellen, zu kompilieren und auszuführen. Da das Ausführen von Java-Programmen Teil der Entwicklung ist, erfordert JDK eine JRE.

4. Bytecode
Bytecode ist der vom Java-Compiler generierte Zwischencode (gespeichert in einer .class-Datei). Mit Hilfe von JVM kann diese .class-Datei auf jedem System ausgeführt werden, wodurch Java plattformunabhängig wird.

Java 1.0
Java betrat die Bühne mit einem Versprechen, das die Softwarelandschaft für immer veränderte: Einmal schreiben, überall ausführen. Es führte die Java Virtual Machine (JVM) ein, die es Entwicklern ermöglicht, Code zu schreiben, der auf jedem Gerät mit einer JVM ausgeführt werden kann, unabhängig von der zugrunde liegenden Hardware. Die Speicherverwaltung wurde automatisiert, was den Entwicklern das Leben erleichtert. Keine größeren Abwertungen – das war erst der Anfang von allem.

Java 1.1
Java 1.1 begann mit der Weiterentwicklung seiner Grundlagen und fügte innere Klassen und Ereignis-Listener hinzu. Diese Funktionen machten Java-Anwendungen dynamischer und interaktiver und verbesserten die Art und Weise, wie Entwickler ihren Code strukturieren und verwalten konnten.

Java 1.2
Mit Java 1.2 begann es spannend zu werden. Es wurden das Collections Framework, Swing (für bessere GUIs) und der JIT-Compiler eingeführt, was die Leistung deutlich beschleunigte. Diese Version machte Java leistungsfähiger für die Handhabung komplexer Anwendungen, insbesondere durch die Einführung der Java 2-Plattform (J2EE) für Unternehmensanwendungen.

Java 1.3
Java 1.3 konzentrierte sich dank der HotSpot-JVM auf Leistung. Die Hinzufügung der Java 2 Platform, Enterprise Edition (J2EE) öffnete die Tür für die Entwicklung skalierbarerer Unternehmensanwendungen. Obwohl es keine bahnbrechenden Funktionen gab, bereitete es den Grundstein für die bevorstehende rasante Entwicklung.

Java 1.4
In dieser Version wurden reguläre Ausdrücke für einen einfacheren Textmusterabgleich, NIO (New I/O) für eine verbesserte I/O-Leistung und Java Web Start eingeführt, das es Benutzern ermöglichte, Anwendungen direkt über einen Webbrowser zu starten. Allerdings verloren Applets langsam an Relevanz und wurden zugunsten modernerer Webtechnologien veraltet.

Java 5
Java 5 (auch bekannt als 1.5) war eines der bedeutendsten Updates in der Geschichte von Java. Es wurden Generika, Anmerkungen und Aufzählungstypen eingeführt, wodurch Java-Code sicherer und effizienter wurde. Außerdem wurde die erweiterte for-Schleife eingeführt, die die Iteration über Sammlungen vereinfachte. Es war eine große Veränderung – so groß, dass sie stattdessen fast Java 1.5 genannt wurde.

Java 6
Java 6 konzentrierte sich stark auf Leistungsverbesserungen, einschließlich Verbesserungen der Java Compiler API und der Java Virtual Machine. Außerdem wurden Funktionen für eine einfachere Integration von Webdiensten eingeführt. Java wurde leistungsfähiger, aber es gab keine größeren Abwertungen – bei Java 6 ging es darum, das bereits Vorhandene zu verfeinern.

Java 7
Mit Java 7 ist die Sprache viel entwicklerfreundlicher geworden. Funktionen wie „Try-with-Ressourcen“ und der Diamant-Operator machten die Codierung sauberer. Zur besseren Parallelverarbeitung wurde das Fork/Join-Framework eingeführt. Allerdings waren Applets offiziell veraltet, was eine Abkehr von der Verwendung von Java in Browsern signalisierte.

Java 8
Java 8 gilt als eines der bedeutendsten Updates überhaupt, da Lambda-Ausdrücke und Streams funktionale Programmierkonzepte in die Sprache einbringen. Dadurch wurde Java viel prägnanter und ausdrucksvoller. Die neue Date/Time-API ersetzte die veraltete Date-Klasse und Standardmethoden in Schnittstellen ermöglichten flexibleren Code. Dennoch wurden Applets offiziell entfernt, da sie nicht mehr relevant waren.

Java 9
Bei Java 9 stand die Modularität im Vordergrund. Die Einführung von Project Jigsaw ermöglichte es Entwicklern, Anwendungen in kleinere, besser verwaltbare Module zu unterteilen und so die Skalierbarkeit zu verbessern. JShell, die interaktive REPL, ermöglichte schnellere Tests und Experimente. In dieser Version wurden auch einige ältere Java EE-Module veraltet, da der Wechsel zu modernen Web-Frameworks Einzug hielt.

Java 10
Java 10 brachte lokale Variablentypinferenz (var), wodurch es einfacher wurde, Variablen zu deklarieren, ohne den Typ explizit anzugeben. Der G1-Garbage Collector erhielt Verbesserungen für eine bessere Leistung. Es gab keine großen Abwertungen, sondern nur einen anhaltenden Vorstoß hin zu einem effizienteren und flexibleren Java.

Java 11
Java 11 war die erste LTS-Version (Long-Term Support) seit Java 8 und ist damit eine wichtige Version für Unternehmen, die Stabilität suchen. Es führte die HTTP-Client-API für eine bessere Webkommunikation ein und markierte die Entfernung veralteter Java EE- und CORBA-Module. Als LTS-Version wurde es zu einer beliebten Wahl für viele Entwickler, die stabile, langfristige Unterstützung benötigten.

Java 12
Mit Java 12 wurden Funktionen wie die JVM Constants API und der experimentelle Shenandoah Garbage Collector eingeführt, die darauf ausgelegt sind, Pausenzeiten zu verkürzen. Außerdem wurde der RMI-Aktivierungsmechanismus abgelehnt, da er von modernen Anwendungen nicht mehr benötigt wurde. Durch diese Änderungen wurde Java noch leistungsfähiger und skalierbarer.

Java 13
Java 13 vereinfachte die Arbeit mit Strings durch die Einführung von Textblöcken für mehrzeilige Strings. Diese Version konzentrierte sich auch auf eine bessere Speicherbereinigung und Leistungsoptimierungen. In dieser Version gab es keine größeren Abwertungen, sondern nur fortlaufende Verbesserungen.

Java 14
Java 14 brachte Datensätze (eine Funktion für unveränderliche Datenklassen), Mustervergleich für Instanzen und Verbesserungen in der Speicherverwaltung. ZGC (Z Garbage Collector) wurde ebenfalls in experimenteller Form eingeführt. Die größte Abwertung war hier die Nashorn-JavaScript-Engine, da modernere JavaScript-Engines eingeführt wurden.

Java 15
Mit Java 15 wurden versiegelte Klassen eingeführt, die die Typen einschränken, die sie erweitern oder implementieren können, und so eine bessere Kontrolle über Ihren Code ermöglichen. Die API für den Fremdspeicherzugriff wurde weiterentwickelt und bietet neue Möglichkeiten für die Interaktion mit dem Speicher außerhalb der JVM. Die RMI-Aktivierungs-API wurde offiziell veraltet.

Java 16
Mit Java 16 wurde der Mustervergleich für „instanceof“ ausgereifter und die Datensatzfunktion wurde vollständig eingeführt. Die Foreign Function & Memory API wurde weiterentwickelt, wodurch Java besser für die native Integration geeignet ist. Bei Java 16 ging es eher um die Festigung von Funktionen als um die Einführung größerer veralteter Funktionen.

Java 17
Java 17, eine LTS-Version, brachte versiegelte Schnittstellen und verbesserte Garbage-Collection-Methoden wie ZGC und Shenandoah. Außerdem wurden JDK-Interna stark gekapselt, um die Sicherheit zu erhöhen. Außerdem wurden einige alte Sicherheitsanbieter abgeschafft, was einen Wandel hin zu moderneren und sichereren APIs markierte.

Java 18
Java 18 konzentrierte sich auf die Verbesserung der Speicherverwaltung und der Foreign Function & Memory API, um besser mit nativem Code interagieren zu können. Außerdem wurde UTF-8 zum Standardzeichensatz gemacht und Java an moderne Internationalisierungsstandards angepasst. In dieser Version ging es eher um interne Verbesserungen als um äußerlich sichtbare Änderungen.

Java 19
Java 19 begann mit der Erforschung von Project Loom (leichte Parallelität) und verfeinerte den Mustervergleich weiter. Die API für den Zugriff auf den Fremdspeicher wurde weiter verfeinert und Werttypen fanden Eingang in die Sprache. Dies sind Schritte zur Modernisierung von Java für komplexe Hochleistungsanwendungen.

Java 20
Java 20 hat Project Loom und Pattern Matching weiter verfeinert, mit verbesserter Unterstützung für Werttypen und neuen Parallelitätsmodellen. Der Zugriff auf den Fremdspeicher wurde weiterentwickelt, wodurch Java bei der Handhabung von nativem Code effizienter wurde und die Leistung für ressourcenintensive Anwendungen verbessert wurde.

Java 21 LTS
Java 21, eine weitere LTS-Version, weitere Verbesserungen in Project Loom, Aufzeichnungsmustern und Skalierbarkeit. Außerdem wurde eine bessere Speicherverwaltung eingeführt und einige der früheren Funktionen finalisiert. Die Abschaffung bestimmter älterer Parallelitätsmodelle markierte einen letzten Schritt auf dem Weg von Java zu moderneren Paradigmen.

Java 22
Bei Java 22 geht es darum, die Sprache mit der endgültigen Unterstützung für Project Loom und weiteren Verbesserungen der Parallelität zukunftssicher zu machen. Der Mustervergleich wird noch verfeinert und es entstehen neue Werkzeuge für skalierbare Anwendungen. Java ist jetzt leistungsfähiger denn je für den Umgang mit leistungsstarken, komplexen Systemen.

Java 23
Die neueste Version, Java 23, erweitert den Mustervergleich und verbessert die native Speicherverwaltung mit der Foreign Function & Memory API. Dies macht Java noch leistungsfähiger für moderne Anwendungen, die mit Systemressourcen auf niedriger Ebene interagieren. Bei Java 23 dreht sich alles um Skalierbarkeit, Leistung und Entwicklerproduktivität und stellt sicher, dass Java auch in den kommenden Jahren relevant bleibt.

Welche Version sollten Sie verwenden?

Für Anfänger ist es im Allgemeinen eine gute Idee, mit einer aktuellen LTS-Version wie Java 17 oder 21 zu beginnen. Diese Versionen werden gut unterstützt und verfügen über die neuesten Funktionen. Da haben Sie es also. Ein anfängerfreundlicher Blick auf die Entwicklung von Java. Lassen Sie sich nicht von den Zahlen überwältigen. Denken Sie daran, dass jede Version auf der vorherigen aufbaut und Java zu einer leistungsfähigeren und vielseitigeren Sprache macht. Viel Spaß beim Codieren.

Das obige ist der detaillierte Inhalt vonWas hat sich in Java-Versionen geändert?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!