Inférence de types sur les variables locales

Définition de types énumérés en Java Les classes enveloppantes

Accès rapide :
La vidéo
Qu'est-ce que l'inférence de type ?
Attention à ne pas confondre JavaScript et Java
Les différents cas d'utilisation supportés
Auto-typage de la variable grâce à une constante
Auto-typage de la variable grâce à une construction d'objet
Auto-typage de la variable grâce à la valeur de retour d'une méthode
Auto-typage de la variable grâce à la valeur de retour d'une méthode générique
Ce qui n'est pas possible de faire
Mise en garde

La vidéo

Cette vidéo vous présente le concept d'inférence de types pour la déclaration de vos variables locales. Cela consiste à déduire le type d'une variable à partir de sa valeur d'initialisation. Cette possibilité existe depuis la version Java SE 10.

Qu'est-ce que l'inférence de type ?

L'inférence de type consiste à déduire les types des données à la compilation. Il existe plusieurs formes d'inférences de types en Java et notamment l'utilisation des lambda et l'utilisation de l'opérateur <> pour l'instanciation des objets basés sur des types génériques. Depuis le Java SE 10, une nouvelle possibilité est apparue : la déduction des types des variables à partir de la valeur d'initialisation. En voici un exemple.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 

public class Demo {

    public static void main( String [] args ) { 
               
        var i = 10;
        System.out.println( i );
        
    }
    
}

Comme vous l'avez remarqué, c'est l'utilisation du mot clé var qui déclenche l'inférence de type. Bien entendu ce mot clé n'existe qu'à partir de la version 10 de Java. Si vous utilisez un environnement d'exécution en version antérieure, ce code ne compilera pas.

L'inférence de type pour les variables locales en Java est spécifié par la JEP (Java Enhancement Proposal) 286 et est repris dans la JSR (Java Specification Request) 383.

Attention à ne pas confondre JavaScript et Java

JavaScript est un langage de programmation inventé, lui aussi, en 1995. C'est un langage de script faiblement typé dont la syntaxe s'inspire de Java, comme son nom le laisse présager. Le mot clé var existe dans ce langage depuis sa version 1.0. Mais attention, il n'a pas exactement le même sens qu'en Java. Effectivement, var permet seulement, en JavaScript, de déclarer une variable et comme dans ce langage, la notion de type est portée par la donnée, et non par la variable, il est possible à tout moment de changer le type de la donnée contenu par la variable. L'exemple suivant s'exécute très bien en JavaScript.

 1 
 2 
 3 
 4 
 5 
 6 
 7 

// Exemple de code JavaScript !!!!
var i = 1;
alert( i );
i = "toto";
alert( i );
i = new Date();
alert( i );

Par contre, en Java, il en va autrement : une fois définie, une variable Java se voit affecter un type. Ce type de données ne pourra plus jamais changer durant la vie de la variable. On est plus fortement typé ! L'exemple de code ci-dessous ne compilera pas en Java.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

public class Demo {
            
    public static void main( String [] args ) {
    
        var i = 1;
        System.out.println( i );        // Ok, i est un entier
        i = "Ouille";                   // Ko : ne compile pas, car i est un entier !!!
        System.out.println( i );
        
    }
    
}

Et voici l'erreur de compilation produite par le compilateur (en version 10.0 minimum, bien entendu, sans quoi vous aurez un autre message d'erreur ;-).

$> javac Demo.java
Demo.java:7: error: incompatible types: String cannot be converted to int
        i = "Ouille";
            ^
1 error
$> 

Les différents cas d'utilisation supportés

Ce nouveau mot clé peut être utilisé dans différentes situations.

Auto-typage de la variable grâce à une constante

C'est l'exemple que nous avons vu plus haut : le type de la constante définie le type de la variable. Ce programme affiche 10, bien entendu.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 

public class Demo {

    public static void main( String [] args ) { 
               
        var i = 10;
        System.out.println( i );
        
    }
    
}

Auto-typage de la variable grâce à une construction d'objet

Il est possible de typer automatiquement une variable en utilisant le type d'une instance nouvellement construite. Voici un exemple d'utilisation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 

public class Demo {

    public static void main( String [] args ) { 
               
        var date = new java.util.Date();
        System.out.println( date.getClass().getName() );
        System.out.println( date );
        
    }
    
}

Auto-typage de la variable grâce à la valeur de retour d'une méthode

Il est possible de déterminer le type d'une variable, déclarée en typage automatique, via le type de la valeur de retour de méthode appelée pour initialiser cette variable. Par exemple, si l'on considère la méthode System.getProperty, elle est définie comme renvoyant une chaîne de caractères : si on utilise cet appel pour initialiser une variable déclarée avec le mot clé var, cette variable sera alors typée java.lang.String. Voici un exemple de code qui en atteste.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 

public class Demo {

    public static void main( String [] args ) { 
               
        var path = System.getProperty( "java.class.path" );
        System.out.println( path.getClass().getName() );
        System.out.println( path );
        
    }
    
}

Auto-typage de la variable grâce à la valeur de retour d'une méthode générique

Pour ceux qui ne connaissent pas encore la notion de classe générique, ce n'est pas grave, car nous en reparlerons plus tard. Pour les autres, sachez que l'exemple suivant compile parfaitement : la variable sera compatible avec le type List<Integer>.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 

import java.util.Arrays;

public class Demo {

    public static void main( String [] args ) { 
               
        var value = Arrays.asList( 10, 20 , 30 );
        System.out.println( value );

    }
    
}

Ce qui n'est pas possible de faire

Il n'est pas possible d'initialiser une variable, en typage automatique, après sa déclaration : les deux étapes (déclaration et initialisation) doivent être faites en même temps.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 

public class Demo {

    public static void main( String [] args ) { 
               
        var value;
        value = 10;
        System.out.println( value );

    }
    
}

Et voici l'erreur de compilation produite par le code précédent.

$gt; javac Demo.java
Demo.java:5: error: cannot infer type for local variable value
        var value;
            ^
  (cannot use 'var' on variable without initializer)
$gt;

De même, il n'est pas possible d'utiliser le mot clé var pour déduire automatiquement le type de retour d'une fonction.

 1 
 2 
 3 

public static var method() {
    return 10;
}

Et voici l'erreur de compilation produite par le code précédent.

$gt; javac Demo.java
Demo.java:3: error: 'var' is not allowed here
    public static var method() {
                  ^
1 error
$gt;

Mise en garde

L'utilisation du mot clé var peut permettre de simplifier l'écriture de vos codes en supprimant parfois des déclarations un peu lourdes (notamment dans le cas de l'utilisation de types génériques ; nous y reviendrons ultérieurement). Pour autant, gardez à l'esprit qu'un programme doit rester lisible et compréhensible. Si vous jugez que vous perdez en lisibilité, alors n'hésitez pas à typer explicitement vos variables.

Définition de types énumérés en Java Les classes enveloppantes