Eclipse


Oracle fait évoluer Java dans son Coin

Il y a quelques temps, j'évoquai dans un article les évolutions à venir de Java 7 concernant le cloud computing.

D'un point de vue plus terre-à-terre, le projet Coin a pour but d'apporter quelques améliorations au JDK actuel. Certaines ont d'ores-et-déjà commencé à être implémentées dans Netbeans 7 béta et Eclipse 3.7 (à venir dans l'année). Le but ici n'est pas de révolutionner le langage mais de lui apporter quelques touches plus "fraîches" dans l'optique de le rendre toujours plus agréable à lire et utiliser. Petit tour d'horizon

Underscores dans les literals

L'intention ici est de simplement rendre le code plus lisible par l'ajout d'underscores dans les entiers par exemple ou les expressions hexadécimales. Exemples :

// Ecriture classique
int i = 1234567890;
// Avec Coin
int i = 1_234_567_890;
// Ou encore
String hexRed = 0xFFCC99;
// Avec Coin
String hexRed = 0xFF_CC_99;

Utilisation des String dans les switch

Encore maintenant, les switch ne sont utilisables qu'avec des types primitifs. L'intérêt est donc d'étendre leur utilisation pour éclaircir et améliorer les performances de certains extraits :

// Avec Java actuel
int monthNameToDays(String s, int year) {
if(s.equals("April") ||
s.equals("June") ||
s.equals("September") ||
s.equals("November"))
return 30;
if(s.equals("January") ||
s.equals("March") ||
s.equals("May") ||
s.equals("July") ||
s.equals("August") ||
s.equals("December"))
return 31;
if(s.equals("February"))
...
else
...
}
}
// Deviendra donc avec Coin
int monthNameToDays(String s, int year) {
switch(s) {
case "April":
case "June":
case "September":
case "November":
return 30;
case "January":
case "March":
case "May":
case "July":
case "August":
case "December":
return 31;
case "February":
...
default
...
}
}

Litéraux pour les collections

L'instanciation de collections est parfois fastidieuse lorsqu'il s'agit par exemple de créer une variable statique dans une classe. Le projet Coin propose donc une nouvelle utilisation :

List<List<String>> monthsInTwoLanguages =
{{"January", "February"},{"Gennaio", "Febbraio"}};

L'opérateur "Diamand"

Le but ici est de simplifier l'écriture des generics, parfois gourmande en caractères :

// Une variable "longiligne" du type :
List<List<List<List<String>>>> list =
new ArrayList<List<List<List<String>>>>();
// Deviendra
List<List<List<List<String>>>> list = new ArrayList<>();

Multi-catch

De la même façon, l'écriture de blocs try-catch peut parfois s'avérer lourde si l'on veut maintenir une bonne gestion des erreurs. Voici donc l'amélioration proposée :

// Un code classique
try {
// Reflective operations calling Class.forName,
// Class.newInstance, Class.getMethod,
// Method.invoke, etc.
} catch(ClassNotFoundException cnfe) {
log(cnfe);
throw cnfe;
} catch(InstantiationException ie) {
log(ie);
throw ie;
} catch(NoSuchMethodException nsme) {
log(nsme);
throw nsme;
} catch(InvocationTargetException ite) {
log(ite);
throw ite;
}
// Pourra s'alléger comme ceci
try {
// Reflective operations calling Class.forName,
// Class.newInstance, Class.getMethod,
// Method.invoke, etc.
} catch(ClassNotFoundException |
InstantiationException |
NoSuchMethodException |
InvocationTargetException e) {
log(e);
throw e;
}

Tout ceci n'est bien sûr qu'un aperçu de ce qui est évoqué dans le projet Coin, lui-même encore à l'état de proposition, mais on peut voir que bien des choses prometteuses sont à venir pour faciliter encore et toujours l'utilisation de Java!

Sources :


Fichier(s) joint(s) :

0 commentaires: