Nouveautés Java 7 – Dolphin

March 17, 2008

Il n’y à toujours pas de JSR officiel décrivant l’ensemble des nouvelles fonctionnalités de Java 7. Cette dernière version porte toujours le nom d’un animal : Dolphin.

Pour cette nouvelle version il devrait y avoir des évolutions dans le langages Java, un nouveau format d’archive (remplaçant du fichier jar) : Java Module System (JSR 277), de nouvelles API et des améliorations de la JVM (support natif de language de script : Javascript, Ruby, PHP).

Nouveautés du langage

Un exemple vaut mieux que plusieurs lignes d’explications :

Document d = <collection></collection>;
element.appendChild ();

Possibilité de définir un membre d’une classe en tant que propriété : les accesseurs seront alors générés à la compilation. Actuellement la syntaxe permettant d’accèder aux accesseurs n’est pas encore certaines : ., =>, -<, #.

public class MyObject {
    private property String member;
}
...
MyObject obj = new MyObject ();
obj.member = "NewValue"; // setMember
String str = obj=>member; // getMember
obj->member = "New Value"; // setMember
str = obj#member; // getMember

Le langage permettrait alors de redéfinir les opérateurs grâce à des annotations.

String str = "first";
switch (str) {
    case "first": doThis (); break;
    case "second": doThat (); break;
    default: throw new IllegalArgumentException ("Unknown: " + str);
}

Autre exemple avec les énumérations :

enum MyColor {
    EMPTY,
    BLACK, WHITE,
    RED, YELLOW, BLUE,
    PINK, PURPLE, ORANGE, GREY;
}

public boolean isPrimary (MyColor c) {
    return c >= MyColor.RED && c < = MyColor.BLUE;
}
class MyObject {
     void doSomething () { ... }
     void doOther () { ... }
     boolean validate () { ... }
}

MyObjet myObject = new MyObject ();
boolean validate = myObject.doSomething ().doOther ().validate ();
try {
     doSomething ();
} catch (IllegalStateException | IllegalAccessException e) {
     // Traitement de l'exception...
}

try {
    doOther (); // Lance des types différences d'exceptions
} catch (final Throwable t) {
    throw t; // Lance les mêmes types d'exceptions
}
Map<string , Object> myMap = new HashMap<> ();

List</string><string> list = new ArrayList<> ();
list.add[0] = "First";
list.add[1] = "Second";
</string>
// Sans Closures :
lock.lock ();
try {
    ++counter;
} finally {
    lock.unlock ();
}

// Avec Closures :
withLock (lock) {
    ++counter;
}

public static <t> T withLock (Lock lock, {=> T throws E}) block) throws E {
    lock.lock ();
    try {
        // Exécution du 'bloc' de code block
        return block.invoke ();
    } finally {
        lock.unlock ();
    }
}
</t>

Modularité

Gestion du versionning

Lorsque l’on développe une application, celle ci à généralement besoins d’une ou plusieurs librairies de classes. Cependant si cette librairie ne peut être fourni avec l’application (problème de license) ou qu’une version spécifique est nécessaire, il n’y à actuellement aucun moyen simple de vérifier la librairie. Les fichiers JAM vont permettrent ceci grâce à une gestion avancée du versionning : 

major[.minor[.micro[.update]]][-qualifier]

Par exemple :

</td> </td> </td> </td> </td> </td> </td> </td> </td>
1+ Version 1 ou supérieur (1 < = x)
1.5+ Version 1.5 ou supérieur (1.5 < = x)
1.5.2+ Version 1.5.2 ou supérieur (1.5.2 < = x)
1* Toutes les versions de la branche 1. (1 < = x < 2)
1.5* Toutes les versions de la branche 1.5. (1.5 < = x < 1.6)
1.5.2* Toutes les versions de la branche 1.5.2. (1.5.2 < = x < 1.5.3)
1.[5+] Version 1.5 ou supérieur dans la branche 1. (1.5 < = x < 2)
1.5.[2+] Version 1.5.2 ou supérieur dans la branche 1.5. (1.5.2 < = x < 1.6)
1.[5.2+] Version 1.5.2 ou supérieur dans la branche 1. (1.5.2 < = x < 2)

Modules

Un fichier JAM est en fait une simple archive (tout comme le fichier JAR) qui peut contenir d’autres JAR (les modules), des ressources (images, …), du code natif (nouvelle gestion : /META-INF/bin/</p> //), des métas-données : MODULE-INF/METADATA.module (version, classe principale, modules nécessaires, attributs, superpackages).

Chaque application aura une bibliothèque de modules (locaux ou distants) permettant la recherche, le chargement (au démarrage ou à l’exécution).

Exemple :

// Déclaration du superpackage :
@Version("1.0")
superpackage com.site.pack {

    // Import de modules
    @VersionConstraint("1.0+")
    import com.site.name;
    @VersionConstraint("1.5*")
    import com.site.xml;

    // Liste des packages
    member package com.site.pack, com.site.pack.impl;

    // Types exportés
    export com.site.pack.*;
}

Nouvelles API

JVM

Article écrit à partir de : Xebia.