Nouveauté Java 7

Les Nouveautés de Dolphin

Comme toutes les anciennes versions, le JDK 1.7 vient avec son lot de changements et de nouveautés. Ces changements sont issus de propositions de développeurs. On remarque certaines nouveautés tirées du langage C#. Les principales nouveautés sont :

Des String dans les switch

La structure conditionnelle switch n'acceptent, actuellement , que les types byte, char, short, int et les enum. Dans Java 7 on pourra aussi utiliser des String.

Gestion automatique des ressources

Les ressources externes au programme tels que les fichiers et les flux d'entrée/sortie n'étaient pas gérés par le Garbage Collector, ainsi les programmeurs devaient utiliser la méthode close() pour les fermer manuellement.
La nouvelle syntaxe propose de déclarer les ressources entre deux parenthèses entre le try et l'accolade ({), et la fermeture sera gérée automatiquement. Ce qui réduit la taille des blocs finally et rend le code source moins verbeux et donc plus lisible.

Diamond syntax

Cette syntaxe a pour but de simplifier la déclaration de vos types paramétrés (Generics) en évitant la duplication de code comme le montre cet exemple:
Code : Java - Sélectionner

1 2 3

List<Map<Integer,List<Boolean>>> liste=new ArrayList<Map<Integer,List<Boolean>>>(); //pourra être remplacé par : List<Map<Integer,List<Boolean>>> liste=new ArrayList<>();

Le compilateur pourra ensuite déduire le type à partir du contexte.

Closures/expressions lambda

Une expression lambda est une fonction anonyme qui peut contenir des expressions et des instructions.
Les Closures sont déjà présentes dans plusieurs langages (C#, Lisp, etc.). Avec Dolphin il est maintenant possible de déclarer une Closure et de l'invoquer avec la méthode "invoke()".
Actuellement, en java c'est possible de s'en sortir sans les closures, en utilisant la réflexivité ou les interfaces et classes internes mais ça reste lourd à mettre en place et trop verbeux. Cette nouveauté touche beaucoup le domaine du Calcul mathématique et de l'intelligence Artificielle.
Exemple d'utilisation:

Secret (cliquez pour afficher)

Code : Java - Sélectionner

1 2 3 4

// déclaration de l'expression lambda #int(int) carre = #(int x)(x * x); // appel de l'expression int valeur=carre.invoke(6);

Multi-catch

Le multi-catch permet de traiter identiquement plusieurs types d'exceptions, afin d'éviter la duplication du code. Il suffit de séparer les différentes classes d'exceptions par le symbole | .
On pourra aussi relancer une exception depuis un bloc catch en utilisant throw e;

java.util.Objects : la fin des NullPointerException

La classe java.util.Objects contient des méthodes statiques(static),simples et efficaces qui opèrent sur les Object d'une manière null-safe.
Dans ce package on trouve, par exemple, la méthode equals(Object a, Object b), elle renvoie true si les 2 Object passés en paramètres sont null et a.equals(b) si a est non null. Cette méthode vous garantira donc une comparaison sans soucis de recevoir un NullPointerException, et vous débarrasse des conditions du genre if(a==null) .
Toutes les autres méthodes de ce package ont le même but : lutter contre les NullPointerException !!

NIO.2 : nouvelle API pour gérer vos fichiers

La classe File du package java.io n'est pas très efficace puisqu'elle ne comporte pas des méthodes pour déplacer/copier les fichiers, et dont les méthodes ne génèrent pas d'exceptions claires, ce qui rend les erreurs quasi-impossibles à retrouver. Donc une nouvelle classe java.nio.file.Path sera ajoutée à l'API standard pour remplacer File. Elle comportera des méthodes pour la copie/création/comparaison des fichiers et des dossiers.

Swing : encore plus beau

Swing aussi subira quelques changements dont l'ajout d'une classe JLayer qui facilitera la personnalisation des composants Swing, l'ajout d'un calendrier et la possibilité de personnaliser les composants avec du CSS .
On peut noter aussi la possibilité de gérer la transparence des composants.

Sun ajoutera aussi le look-and-feel Nimbus dans le package javax.swing.* afin de donner un aspect plus moderne à vos GUI. La particularité de Nimbus vient du fait qu'il soit facilement personnalisable.Cependant Metal sera toujours le look-and-feel par défaut pour des problèmes de rétro-compatibilité.
Si vous avez installé le jdk 6 update 10, vous pouvez utiliser Nimbus en ajoutant ce bout de code à vos programmes:
Secret (cliquez pour afficher)

Code : Java - Sélectionner

1 2 3 4 5 6

for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) { if ("Nimbus".equals(info.getName())) { UIManager.setLookAndFeel(info.getClassName()); break; } }

Les superpackages : plus de modularité

Actuellement, pour qu'une classe soit utilisable dans deux packages différents(ou plus) elle doit être déclarée public. Le problème est qu'elle devient visible partout, même pour le client. Avec Java 7, il suffira de mettre les différents packages qui utilisent la classe dans un superpackage (un fichier superpackage.java) et la classe sera visible uniquement pour toutes les autres classes et interfaces du superpackage.

JAM : Le remplaçant du JAR

le JAM (Jar 2.0) est une amélioration du format JAR. En fait un fichier JAM est un JAR auquel on ajoute quelques informations tel que le nom,les imports,les classes publiques, la version... Ceci dans le but de fournir plus d'infos pour les utilisateurs d'une bibliothèque ou autre.

Garbage-First : Le nouveau Garbage Collector

Le G1 GC est un nouveau GC qui sera introduit dans la VM de sun du JDK 7. G1 utilise le parallélisme qui existe dans le matériel d'aujourd'hui. Il utilise tous les processeurs disponibles afin de réduire le temps des pauses (pauses nettoyage) imposés aux threads de l'application Java. Contrairement à l'ancien GC, G1 effectue le compactage du tas au fil du temps.Ce compactage élimine les problèmes de fragmentation potentielles pour assurer un bon fonctionnement pendant de longues périodes. Une version expérimentale de G1 est disponible avec le JDK1.6 update 14.

Support natif des langages à typage dynamique

La JVM permet depuis quelques années le support des langages autres que Java sur la JVM (JSR223). Ce sont généralement des langages de très haut niveau utilisant un typage dynamique (le type d'une variable n'est pas défini à sa déclaration, comme en Ruby, Python ou PHP par exemple). Pour le moment, la JVM ne supporte pas nativement le typage dynamique, on est donc obligé d'utiliser de l'introspection pour découvrir le type retourné par une méthode. Ça fonctionne, mais c'est lent ; la nouvelle JVM qui arrive avec Java 7 ajoute donc une instruction au bytecode Java qui permet d'effectuer cela sans utiliser l'introspection, de façon beaucoup plus performante (JSR292).