Zuerst sollte man sich jedoch im Versionsdschungel zurechtfinden [1]. Das neue Release wurde nicht mehr anhand der Version des JDK nummeriert, sondern erhielt eine neue Versionsnummer 5.0. Damit ist der neue Name der Java-Plattform Java 2 Platform Standard Edition 5.0 oder kurz J2SE 5.0. Das JDK und JRE wurden entsprechend benannt mit J2SE Development Kit 5.0 (JDK) und J2SE Runtime Environment 5.0 (JRE). Aus den Kürzeln j2sdk und j2re wird nun wieder jdk und jre. Nicht zuletzt wird die Versionsnummer 1.5 dennoch verwendet. Wenn Sie sich die Versionsnummer über java -version ausgeben lassen, wird die Version 1.5.0 zurückgegeben. Auch die Webseite des JDK ist unter java.sun.com/j2se/1.5.0/ erreichbar.

Entwicklungsschwerpunkte

Bei der Entwicklung der J2SE 5.0 wurden die Schwerpunkte laut Graham Hamilton auf sechs Themengebiete gelegt. Eine herausragende Qualität wurde als erster Punkt genannt. Die Verbesserung der Performance und Skalierbarkeit, auch auf großen Multiprozessormaschinen, wurde als nächster Punkt genannt. Erweiterte Überwachungs- und Managementfunktionen kamen als dritter Punkt ins Spiel. Über die JConsole wird bereits ein Monitoring-Tool für lokale und Remote-Anwendungen mitgeliefert. Sie können damit die Performance und Ressourcennutzung von Anwendungen auswerten. Als Viertes wurden die verbesserten Funktionen für Desktop Clients genannt. Neue Look&Feels sowie zahlreiche Verbesserungen im AWT, Swing oder Java 2D sorgen für eine attraktive Bedienung von Java-Anwendungen. Unter Easy of Development verbergen sich unter Punkt fünf zahlreiche neue Spracherweiterungen, von denen Annotations (Metadaten) als Favorit von Graham Hamilton gehandelt wurden. Sicher schon allein deshalb, da sie eine wichtige Rolle in der kommenden J2EE spielen. Interessant ist, dass erstmals seit dem JDK 1.0 Erweiterungen in den Sprachgrundlagen Javas vorgenommen wurden. Für die Entwickler soll sich durch diese Spracherweiterungen die Erstellung und Lesbarkeit des Sourcecodes spürbar verbessern. Last, but not least kam als Punkt sechs die Sprache auf die aktualisierten Tools zum Parsen und Verarbeiten von XML. Dazu wurde Crimson durch Xerces ersetzt und Xalan auf die Version 2.6.x aktualisiert. Einen großen Beitrag leistete bei den Neuerungen der Java Community Process, der 15 JSRs hervorbrachte, die in die J2SE 5.0 eingeflossen sind [2].

Neue Spracheigenschaften

Das Ziel aller Spracherweiterungen ist eine einfachere, verständlichere Eingabe des Sourcecodes bei möglichst wenigen Änderungen in der JVM. Und bis auf die Verwendung von Generics und Annotations ist die Verwendung dieser Erweiterungen auch wirklich sehr einfach. Im Gegensatz zur Beta 1 muss der Schalter -source 1.5 zur Unterstützung der J2SE 5.0-Erweiterungen nicht mehr angegeben werden, da dies jetzt die Standardeinstellung ist.

Mittels variabler Parameterlisten in Methoden vereinfacht sich deren Aufruf, z.B. zur Formatierung von Strings. Der variable Parameter muss als letzter Parameter einer Methode angegeben werden und wird durch eine Ellipse eingeleitet. Intern wird ein Array des betreffenden Typs übergeben.

1. int summe(int ...summanden)
2. {
3. int summe = 0;
4. for(int i: summanden)
5. summe = summe + i;
6. return summe;
7. }
8. System.out.println(summe(1,2,3,4,5));

Die verbesserte for-Schleife vereinfacht die Iteration über Collections und Arrays. Collections müssen dazu das neue Interface Iterable implementieren.

1. int[] feld = {1,2,3,4,5};
2. for(int f: feld)
3. System.out.println(f);

Durch statische Importe soll die Verwendung von öffentlichen, statischen Konstanten, Variablen und Methoden vereinfacht und so der Code besser lesbar gemacht werden. Es werden dabei statische Elemente wie Klassen und Interfaces importiert. In Zukunft sollten statische Elemente in Klassen deklariert und durch einen statischen Import eingebunden werden.

1. import static java.lang.Math.sqrt;
2. // oder für alle statischen Elemente
3. // import static java.lang.Math.*;
4. // statt double d = Math.sqrt(2);
5. double d = sqrt(2);

Die J2SE 5.0 unterstützt die automatische Konvertierung von primitiven Datentypen in ihre Wrapper und umgekehrt durch das Auto(un)boxing. Dies vereinfacht die Übergabe der entsprechenden Typen an Methoden und die Verarbeitung von Rückgabewerten. Damit ist die Verwendung beispielsweise in Collections sinnvoll, die nur Objekte verwalten können. Auto(un)boxing wird häufig in Kombination mit Generics und der for-Schleife verwendet.

1. int i = getInt(100);
2. Integer getInt(Integer wert)
3. {
4. int i = wert;
5. return i;
6. }

Typsichere Aufzählungen werden durch spezielle Aufzählungsklassen unterstützt, die intern von der Klasse Enum abgeleitet sind. Der Compiler kann jetzt die Typsicherheit bei der Verwendung der Konstanten prüfen. Damit sind die Zeiten vorbei, in denen Aufzählungskonstanten durch int-Zahlen realisiert wurden. Die Aufzählungskonstanten sind Objekte der entsprechenden Aufzählung und besitzen automatisch eine String-Repräsentation und eine Ordinalzahl. Da Aufzählungen Klassen sind, können Sie auch zusätzliche Methoden und Variablen besitzen. Weiterhin können Sie Konstruktoren definieren und den Konstanten Parameter anfügen (siehe Klasse Fahrzeuge). Noch trickreicher wird es, wenn Konstanten ihre speziellen Methoden besitzen, die durch das Überschreiben einer abstrakten Methode der Aufzählungsklasse realisiert werden (siehe Klasse MinMax).

1. enum Noten { EINS, ZWEI, DREI, VIER, FUENF };
2. enum Fahrzeuge
3. {
4. BMW(110), AUDI(100), OPEN(50);
5. private int ps;
6. Fahrzeuge(int ps)
7. { this.ps = ps; }
8. public int getPS()
9. { return ps; }
10. }
11. enum MinMax
12. {
13. MINIMUM{ int rechne(int z1, int z2)
14. { return Math.min(z1, z2); }},
15. MAXIMUM{ int rechne(int z1, int z2)
16. { return Math.max(z1, z2); }};
17. abstract int rechne(int z1, int z2);
18. }

In Zukunft soll es vermieden werden, dass für bestimmte Anwendungsgebiete spezieller Code geschrieben werden muss (Stubs etc.), der sich auch direkt aus dem Sourcecode generieren ließe. Damit später klar ist, auf Basis welcher Informationen Sourcecode generiert werden soll, werden bestimmte Programmelemente mit Annotations (Anmerkungen - auch als Metadaten bezeichnet) versehen. Annotations beeinflussen dabei nicht direkt den Programmablauf, können aber später durch separate Tools ausgewertet werden. Typische Fälle sind RMI, Web Services oder EJBs (hier werden Annotations in der nächsten Version eine große Rolle spielen). Mittels Annotations können Sie die folgenden Programmelemente mit speziellen Informationen versehen: Packages, Klassen, Interfaces, Aufzählungen, Methoden, Parameter, Variablen und Konstanten. Je nach Annotation-Typ können diese im Sourcecode (z.B. über das neue Tool APT - Annotation Processing Tool), in der *.class-Datei oder zur Laufzeit über Reflection ausgewertet werden. Die J2SE 5.0 liefert bereits sechs Annotations mit. Natürlich wird es erst spannend, wenn Sie selbst eigene Annotation-Typen definieren. Dazu kommt eine veränderte Form eines Interfaces zum Einsatz.

1. @Retention(RetentionPolicy.RUNTIME)
2. @Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
3. @interface BemerkungLang
4. {
5. String bemerkung();
6. int typ();
7. }
8. // und Verwendung über ...
9. @BemerkungLang(bemerkung="Zweite Bemerkung",typ=10)
10. public boolean berechne() ...

Generische Klassen, Methoden oder einfach Algorithmen haben die Gemeinsamkeit, dass ihre Implementierung bis auf die Verwendung von ein oder mehrerer Datentypen identisch ist. Das typische Einsatzgebiet von generischen Klassen etc. ist das Collections API. Im Gegensatz zu Templates aus C++ sind Generics in Java anders implementiert. Die korrekte Verwendung und Implementierung eigener generischer Typen verlangt einen gewissen Einarbeitungsaufwand, da Generics zahlreiche Fallstricke besitzen. Grundsätzlich basiert die Implementierung auf einer Typ Erasure, d.h., der Compiler entfernt sämtliche generische Typinformation, sodass sich der Bytecode für die JVM genau so verhält, wie ohne die Verwendung von Generics.

1. // Verwendung bisher
2. ArrayList al = new ArrayList();
3. al.add("Element 1");
4. String s = (String)al.get(0);
5. // und über Generics
6. List<Integer> alI = new ArrayList<Integer>();
7. alI.add(new Integer(100));
8. alI.add(new String("100")); // => Compilerfehler
9. int i = alI.get(0); // => Cast entfällt

Verbesserungen der Performance

Im Bereich Performance hat sich eine Menge getan. Die Neuerungen verteilen sich über vier Haupt-Features. Das Class Data Sharing soll die Startzeit einer Anwendung verbessern und die Speicherauslastung verringern. Dies wird über ein von mehreren Anwendungen gemeinsam genutztes Archiv realisiert, das die Core-Klassen einmalig in einen bestimmten Speicherbereich lädt. Die gemeinsam genutzten Klassen werden dabei in einer Datei classes.jsa (Java Shared Archive) verwaltet. Nach dem Start einer zweiten Anwendung müssen diese Klassen dann nicht erneut geladen werden.

Über die dynamische Ermittlung des Rechnertyps (Client oder Server) werden über die Server-Class Machine Detection sofort die optimalen Einstellungen für eine Anwendung vorgenommen, falls keine weiteren Konfigurationen gemacht wurden. So benötigt eine Serveranwendung zwar eine längere Startzeit, zeigt aber beispielsweise ein schnelleres Antwortverhalten. Der Garbage Collector wurde speziell auf Servermaschinen auf den parallelen Modus umgestellt. Die Standardwerte für die Speichernutzung wurden angepasst. Damit sollen die sonst notwendigen Anpassungen auf der Kommandozeilenebene vermieden werden. Für die extensive Arbeit mit Zeichenketten wurde die neue Klasse StringBuilder geschaffen, die im Gegensatz zur Klasse StringBuffer auf die Synchronisation verzichtet.

Erweiterungen in der Klassenbibliothek

Zur Vereinfachung zahlreicher Aufgaben wurden neue Klassen für die Prozessverwaltung, Formatierung von Strings (z.B. über die von C übernommene Funktion printf) und zum Einlesen von Daten über Streams mittels der Klasse Scanner neu aufgenommen. Das Concurrency API stellt Klassen für konkurrenten Zugriff auf Variablen, Synchronisations- und Sperrmechanismen bereits. Das gesamte Collection API wurde auf Basis von Generics reimplementiert. Zusätzlich wurden unter anderem neue Interfaces Iterable und Queue zur Unterstützung von Collections durch die verbesserte for-Schleife bzw. die Implementierung von Queue-Datenstrukturen geschaffen. Das Package javax.management und seine Sub-Packages enthalten zahlreiche Klassen und Interfaces für die Überwachung und das Management von Java-Anwendungen. Das Reflection API wurde erweitert, um Annotations, Aufzählungen und variable Parameterlisten zu unterstützen.

1. // Einlesen von Werten über die Konsole
2. Scanner s = new Scanner(System.in);
3. double d = s.nextDouble();
4. int i = s.nextInt();
5. // Formatieren von Zeichenketten
6. String s = new Formatter().format("%d", 100).toString();
7. System.out.printf("%-15s %6.2f EUR\n", "Artikel", 2.50);

GUI-Entwicklung

Wenn Sie in ein Restaurant gehen, ist der Anblick eines leckeren Essens fast genauso wichtig wie dessen schmackhafte Herrichtung. Nun, bei der Anwendungsentwicklung ist es ebenfalls so. Bei einigen Anwendungen könnte man sogar auf den Gedanken kommen, dass die Entwickler nicht viel weiter gekommen sind, als eine schöne Benutzeroberfläche ohne jegliche Funktion zu entwickeln. Zumindest können wir alle mit neuen Look&Feels in der J2SE 5.0 rechnen. Das Standard-Java-Look&Feel wird beispielsweise durch das Ocean L&F abgelöst, was letztendlich keine völlig neue, aber dennoch angepasste Darstellung der grafischen Elemente zeigt. Für Hersteller von Anwendungen, die verschiedene Skins unterstützen, kann das anpassbare Synth L&F interessant sein. Der Vorteil gegenüber bereits vorliegenden L&Fs ist bei Synth, dass es nicht über Programmierung sondern durch eine XML-Datei konfiguriert wird. Die Klasse JTable wurde mit einer Druckunterstützung ausgerüstet und für die Liebhaber kleiner aber feiner Änderungen können nun Komponenten direkt über die Methode add() in einen JFrame eingefügt werden.

1. JFrame jf = new JFrame();
2. JButton jb = new JButton();
3. jf.add(jb);

Das AWT enthält neue Methoden zur Ermittlung der aktuellen Mausposition, zum dauerhaften Setzen von Fenstern in den Vordergrund und dem Setzen der Standardposition eines neuen Fensters. Java 2D wurde um die Hardware-Unterstützung von OpenGL erweitert. Das Image I/O API unterstützt zusätzlich lesend und schreibend die Grafikformate BMP und WBMP. Zur verbesserten Internationalisierung kann das AWT jetzt das Unicode API unter Windows 2000 und Windows XP verwenden. Die Zeichensatzverarbeitung basiert jetzt generell auf der Version 4.0 des Unicode-Standards.

Was es sonst noch gibt

Zur Weitergabe von Anwendungen, insbesondere über das Web, wurde ein neues Packformat für JAR-Archive PACK2000 implementiert. JAXP wurde auf die Version 1.3 updatet. Der XML-Parser Crimson wurde durch den zum De-facto-Standard zählenden Parser Xerces ersetzt und für die Transformation über XSLT wurde Xalan durch eine aktuelle Version ersetzt. Zu bemerken ist hier, dass für die im JDK befindlichen Klassen von Xerces und Xalan spezielle Package-Namen (com.sun.org.apache.xerces.internal bzw. com.sun.org.apache.xalan.internal) verwendet wurden, um später aktuellere Versionen einfacher über den CLASSPATH zugänglich zu machen und nicht wie bisher über den Endorsed Standards Override Mechanism.

Fazit

Die angegebenen Neuerungen und Verbesserungen sind nur die sofort ins Auge springenden Punkte in der J2SE 5.0. Im Detail gibt es noch zahlreiche weitere Dinge, aber wer hätte auch anderes erwartet. Ein erster Einstieg sollten für jedermann die Release Notes unter [3] sein. Hier erhalten Sie eine Übersicht, von der aus Sie sich zu den entsprechenden Neuerungen in den APIs bewegen können. Ich bin bisher mit den Neuerungen sehr gut gefahren und finde es besonders erwähnenswert, dass auch für die Entwickler von einfachen Standardanwendungen sehr hilfreiche Dinge eingeflossen sind, man denke an das einfache Einlesen von Zahlen über die Klasse Scanner von der Konsole. Für den Profi sind sicher Annotations sowie die Management- und Überwachungsfunktionen zur Verbesserung der Leistungsfähigkeit der eigenen Anwendungen eine bedeutende Neuerung. Also dann, viel Spaß mit dem Tiger. Ach, und für alle Pferdefreunde und die, die es nicht erwarten können - die nächste Version läuft unter dem Codenamen Mustang und ist damit wohl nicht weniger wild.

Links und Literatur
[1] Namensgebung der j2SE 5.0: java.sun.com/j2se/naming_versioning_5_0.html
[2] Java Specification Requests: jcp.org/en/jsr/all
[3] Featureliste der J2SE 5.0: java.sun.com/j2se/1.5.0/docs/relnotes/features.html
[4] Download der J2SE 5.0: java.sun.com/j2se/1.5.0/download.jsp