Java 25 : Import de Modules

Avec Java 25, une nouvelle fonctionnalité a été introduite : l’import de modules. Cette nouveauté vise à simplifier la gestion des imports dans les projets Java, notamment dans les applications de grande taille où les listes d’importations peuvent devenir longues et difficiles à maintenir. Cet article explique en détail le fonctionnement, les avantages, les limites et les bonnes pratiques autour de cette fonctionnalité.

Ces nouveautés s’inscrivent dans le processus des JEPs (Java Enhancement Proposals).

Contexte : packages, modules et imports

En Java, un package est un regroupement logique de classes et d’interfaces. Il permet d’organiser le code par fonctionnalités. Depuis Java 9, le langage introduit le concept de module, une unité de plus haut niveau qui regroupe plusieurs packages et définit clairement :

Les packages qu’il exporte (accessibles depuis d’autres modules)
Les modules dont il dépend (via la directive requires)

Jusqu’à Java 24, les classes Java devaient importer les types individuellement (par nom complet ou par joker *). Le système d’importation reposait sur les packages, et non sur les modules. Avec Java 25, cela change.

Importer un module

La nouvelle syntaxe permet d’importer un module entier en une seule ligne :

import module java.base;

Cela rend accessibles tous les types publics (classes, interfaces, enums) des packages exportés par le module concerné, ainsi que ceux des modules transitivement requis.

Par exemple, java.base est le module fondamental de Java. Il contient entre autres les packages :

java.lang (importé automatiquement)
java.util
java.io
java.net

Avec l’import de module, toutes les classes de ces packages deviennent disponibles sans avoir à les importer individuellement.

Exemple concret

Imaginez la déclaration suivante :

import module java.sql;

Cela rend accessibles les types publics des packages exportés par java.sql, comme java.sql.Date, Connection, Statement, etc.

On peut combiner plusieurs imports de modules :

import module java.base;
import module java.sql;
import module java.desktop;

Conflits de noms

L’importation de plusieurs modules peut introduire des conflits de noms, notamment lorsque deux modules exportent des types portant le même nom.

Par exemple :

java.util.Date (dans java.base)
java.sql.Date (dans java.sql)
java.awt.List (dans java.desktop)
java.util.List (dans java.base)

Si plusieurs modules contenant ces types sont importés via la directive import module, l’utilisation simple des noms Date ou List devient ambiguë. Le compilateur ne peut plus résoudre automatiquement le bon type.

Règles de résolution

Lorsqu’un nom de type est utilisé, le compilateur applique les priorités suivantes pour le résoudre :

Import explicite de type : import java.sql.Date;
Import joker de package : import java.util.*;
Import de module : import module java.base;

Autrement dit, un import précis aura toujours la priorité sur un import de module.

Bonnes pratiques

Pour tirer parti de cette nouvelle fonctionnalité sans introduire de confusion, il est recommandé de :

Privilégier les imports explicites pour les types sujets à ambiguïté (ex. Date, List)
Utiliser les imports de module pour accéder rapidement à des ensembles de types stables et non ambigus
Organiser les imports par catégorie :

// Imports de modules
import module java.base;
import module java.sql;
// Imports de packages
import java.util.*;
// Imports de types explicites
import java.sql.Date;

Limites

Les imports de module sont une extension de confort, non une obligation
Cette fonctionnalité peut rendre le débogage plus difficile si les conflits ne sont pas anticipés
Les IDE peuvent ne pas encore gérer parfaitement cette nouveauté dans leurs outils d’autocomplétion

Conclusion

L’import de modules en Java 25 est une fonctionnalité utile pour simplifier les fichiers sources et réduire la verbosité des déclarations d’importation. Elle doit cependant être utilisée avec discernement, en particulier lorsqu’on travaille avec des types qui existent dans plusieurs modules. Comme pour toute nouveauté du langage, l’expérimentation et la pratique aideront à en tirer pleinement parti.