Was Java 7 Neues bringt

Auf den ersten Blick ist Mark Reinhold nur zu beneiden. Seit Java 1.1 ist er an der Entwicklung der Kernkomponenten der Sprache beteiligt und mittlerweile Chef der Java-Entwicklung. Sein jüngster Erfolg ist die Veröffentlichung der von vielen Programmierern heiß ersehnten Java-Version 7 im Juli 2011 [1].

Das ist kein Randereignis in der IT-Welt, ist das plattformunabhängige Java doch seit Jahren eine der erfolgreichsten Sprachen und erfreut sich einer großen und aktiven Entwicklergemeinde. Damit dies so bleibt, bietet die neue Version Vereinfachungen für Developer und verleiht Oberflächen ein neues Aussehen.

Open Source?

Dabei hatte eine der ersten für die neue Version nötigen Entscheidungen gar nichts mit Technik zu tun: Das von Sun entwickelte Java ist zwar seit jeher kostenlos für Linux und andere Plattformen verfügbar, der Großteil der Quellen blieb jedoch trotz heftiger Kritik fest unter Verschluss. Ab Mitte 2006 gab sich Sun zunehmend offener und stellte die Sourcen unter die GPL. Damit konnte erstmals jeder Interessierte Einblick nehmen und Änderungen vornehmen.

Offene Quellen sind aber nur die halbe Miete, daher richtete Sun mit dem Java Community Process auch ein Regelwerk für die Koordinierung der Weiterentwicklung ein. In dem Steuerungskomitee nahmen Branchengrößen wie IBM und SAP, aber auch Red Hat und die Apache Foundation als Vertreter der Open-Source-Gemeinde Platz.

Dieser Brückenschlag stellte für Suns Kronjuwel einen radikalen Wechsel in Richtung freie Software dar. Lohn der Mühe ist jetzt Java 7, das erstmals als Quelltext [2] und fertig kompiliert [3] bereitsteht. Die Version enthält Verbesserungen in allen drei Bereichen, die die Entwicklung von Java-Programmen vereinfachen: Sprache, Bibliotheken und Laufzeitumgebung.

Einfachere Sprache

Am auffälligsten sind die Erweiterungen der Sprache selbst. Viele Änderungen entstammen dem Projekt Coin [4] unter der Leitung von Joe Darcy. Dessen Ziel sind kleine Änderungen der Java-Syntax, die den Quelltext besser lesbar und schlanker machen sollen.

Im Vergleich zu anderen Sprachen ist Java als recht geschwätzig verschrien, gerade die mit Java 5 eingeführten Typ-sicheren Container (Generics) sind gefürchtet: Typdeklarationen muss der Programmierer sowohl bei der Variablendeklaration als auch bei der Erzeugung eines Containers angeben. Diese Arbeit übernimmt nun der Compiler, er ersetzt die neue Schreibweise »<>« (Diamond-Operator) automatisch durch den richtigen Typ (Listing 1, Zeile 4).

01 // JDK 6
02 Map<String, List<Integer>> altName2msn = new HashMap<String, List<Integer>>();
03 // JDK 7, Diamond Operator
04 Map<String, List<Integer>> coinName2msn = new HashMap<>();
05
06 // JDK 6
07 OutputStream fos = null;
08 try {
09     fos = new FileOutputStream("ausgabe.txt");
10     fos.write(42);
11 } catch (IOException exp) {
12     // ...
13 } finally {
14     try {
15         if (fos != null) {
16             fos.close();
17         }
18     } catch (IOException exp) {
19         // ...
20     }
21 }
22
23
24 // JDK 7, Try with Resource and multiple catch
25 try (OutputStream out = new FileOutputStream("ausgabe.txt")) {
26     out.write(42);
27 } catch (ArithmeticException | IOException exp) {
28     // ...
29 }
30
31 // JDK 6
32 long SOURCE_ENTITY_TYPE_MASK = Long.parseLong("10000000" + //
33         "00000000" + //
34         "00000000" + //
35         "10000000", 2);
36 // JDK 7
37 long coin = 0b10000000_00000000_00000000_10000000L;
38
39 // JDK 7, Datei kopieren
40 File src = new File("eingabe.txt");
41 File dest = new File("ausgabe.txt");
42 Files.copy(src.toPath(), dest.toPath(), StandardCopyOption.REPLACE_EXISTING);

Die korrekte Behandlung externer Abhängigkeiten wie Dateien oder Datenbanken ist in jeder Sprache aufwändig und bietet viel Raum für potenzielle Fehler, die zur Laufzeit sauber abzufangen sind. Mit dem neuen Konstrukt »try-with-resources« muss der Programmierer dies nicht mehr explizit angeben. Das verkleinert den Code beispielsweise bei Problemen, wie sie durch offene Handles entstehen. Das erweiterte Try-Statement enthält nun das Öffnen der Ressourcen, sie werden beim Verlassen des Try-Blocks auf jeden Fall geschlossen, auch ohne dass der Programmierer dies explizit angibt.

In den Genuss dieser einfachen Schreibweise (Listing 1, Zeile 25) kommen neben dem einfachen File-I/O auch Datenbank-Verbindungen und -Statements. Das Catch-Statement haben die Java-Entwickler bei dieser Gelegenheit ebenfalls verbessert, es kann nun mehrere Ausnahmen auf einmal fangen, statt für jeden Fehlertyp ein eigenes Catch-Statement zu verlangen (Listing 1, Zeile 27).

Aber auch anderswo finden sich Spuren der Detailpflege: Das Switch-Statement schwimmt sich ein Stück weit von seinem C-Vorfahren frei. Bisher ließ es sich nur mit Integers und Enumerationen verwenden, nun kann es auch mit String-Konstanten arbeiten. Zahlen im Quelltext dürfen Programmierer mit dem Präfix »0b« wie bei Python oder beim GCC binär schreiben, Unterstriche gliedern sie zur besseren Lesbarkeit auf (Listing 1, Zeile 37).