Java 7 wird mit einigen sprachlichen Veränderungen kommen. Welche das sind, möchte ich an einem Quellcode-Beispiel präsentieren.

In Geertjan Wielengas Blog bin ich gestern auf einen Artikel gestoßen, der die Unterstützung von Java 7 in NetBeans 7.0 beschreibt. Der dort verwendete Quellcode, sieht in den verschiedenen Javaversionen wie folgt aus:

Java 6

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 /**
  **
  ** @author Witi
  */
 public class Test {
     public static void main(String... args) throws IOException {
         final List<String> list = new ArrayList<String>();
         final Map<String, Integer> map = new HashMap<String, Integer>();
         final String a = "ehlo";
         if (a.equals("foo")) {
             System.err.println("FOO");
         } else if (a.equals("bar")) {
             System.err.println("BAR");
         }
         try {
             throw new FileNotFoundException("asdf");
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }
         InputStream in = null;
         try {
             in = new FileInputStream("foo.txt");
             int k;
             while ((k = in.read()) != -1) {
                 System.out.println("k");
             }
         } finally {
             if (in != null) {
                 try {
                     in.close();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
                 in = null;
             }
         }
     }
 }

Java 7:

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 /**
  **
  ** @author Witi
  */
 public class Test {
     public static void main(String... args) throws IOException {
         final List<String> list = new ArrayList<>();
         final Map<String, Integer> map = new HashMap<>();
         final String a = "ehlo";
         switch (a) {
             case "foo":
                 System.err.println("FOO");
                 break;
             case "bar":
                 System.err.println("BAR");
                 break;
         }
         try {
             throw new FileNotFoundException("asdf");
         } catch (FileNotFoundException | IOException e) {
             e.printStackTrace();
         }
         try (final InputStream in = new FileInputStream("foo.txt")) {
             int k;
             while ((k = in.read()) != -1) {
                 System.out.println("k");
             }
         }
     }
 }

Zu allererst springt einem förmlich ins Auge, dass der Quellcode in Java 7 geringer und sogar lesbarer geworden ist. Wer schon einmal in C# entwickelt hat, dem wird das untere try-Konstrukt zur automatischen Ressourcenfreigabe sehr bekannt vorkommen.

Java 7 Features

Diamand Operator

Aus new HashMap<String, Integer>() wird new HashMap<>(). Viel weniger Schreibarbeit. Auf der anderen Seite vervollständigen aktuelle IDEs das sowieso automatisch.

Strings in switch-case

Irgendwie ziemlich traurig, dass so eine verbreitete und bekannte Programmiersprache so ein Feature erst heute unterstützen wird. Lieber zu spät als gar nicht.

Multi-Catch

catch (FileNotFoundException | IOException e) Das ist doch auch mal eine schöne Sache, was den Quellcode wiederum sauberer macht.

Automatic resource management (ARM)

Eins der vielen Gründe, warum Java-Applikationen gerne mit vielen Speicherlecks daherkommen. Man möge zwar denken, dass es für einen Java- Entwickler selbstverständlich ist, die verwendeten Ressourcen wieder freizugeben, leider ist das nur Utopie. Sogar in Lehrbüchern musste ich des Öfteren feststellen, dass die Autoren das Wort finally noch nie in ihrem Leben gehört haben.

Durch ARM werden diese Autoren dieses Schlüsselwort auch nicht mehr lernen müssen und C# Entwickler einen Grund weniger haben über Java zu schimpfen.

blogroll
tags