{"id":519757,"date":"2024-10-21T16:29:15","date_gmt":"2024-10-21T15:29:15","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=idea&p=519757"},"modified":"2025-09-16T15:06:15","modified_gmt":"2025-09-16T14:06:15","slug":"java-23-et-intellij-idea","status":"publish","type":"idea","link":"https:\/\/blog.jetbrains.com\/fr\/idea\/2024\/10\/java-23-et-intellij-idea\/","title":{"rendered":"Java 23 et IntelliJ IDEA"},"content":{"rendered":"Les nouveaut\u00e9s introduites par Java 23 concernent les fonctionnalit\u00e9s du langage, l’API principale et la JVM, et pr\u00e9sentent un int\u00e9r\u00eat tant pour les d\u00e9butants que pour les d\u00e9veloppeurs exp\u00e9riment\u00e9s. La version 2024.2 d’IntelliJ IDEA<\/a> fournit une prise en charge des fonctionnalit\u00e9s de Java 23.\n\nIl n’est pas toujours \u00e9vident de suivre le rythme des publications des nouvelles versions de Java et de savoir tout ce qui a chang\u00e9, pourquoi, et comment tirer parti de ses derni\u00e8res mises \u00e0 jour et nouvelles fonctionnalit\u00e9s. Dans cet article, je pr\u00e9sente les principales nouveaut\u00e9s et mises \u00e0 jour de fonctionnalit\u00e9s de Java 23, notamment en termes de syntaxe et de s\u00e9mantique, ainsi que les points particuliers pour lesquels elles facilitent le travail des d\u00e9veloppeurs, tout en expliquant comment IntelliJ IDEA peut vous aider \u00e0 les utiliser au mieux.\n\nJ’ai choisi de parler plus particuli\u00e8rement des types de donn\u00e9es primitifs dans la correspondance de motifs<\/a>, de la capacit\u00e9 d’importer des modules<\/a> dans les bases de code, de la possibilit\u00e9 d’utiliser Markdown dans les commentaires de la documentation<\/a>, des classes d\u00e9clar\u00e9es implicitement et des m\u00e9thodes d’instance main<\/a>\u00a0et des corps de constructeur flexibles<\/a>. Si cela vous int\u00e9resse, la liste de toutes les fonctionnalit\u00e9s de Java 23 est disponible ici<\/a>.\n\nAvant d’examiner les fonctionnalit\u00e9s de Java 23, commen\u00e7ons par voir configurer rapidement IntelliJ IDEA.\n

Configuration d’IntelliJ IDEA<\/h2>\nLa prise en charge de Java 23 est disponible dans la version majeure la plus r\u00e9cente d’IntelliJ IDEA<\/a>.\n\nCommencez par d\u00e9finir le SDK sur Java 23 dans Project Settings<\/em>. Vous pouvez choisir de configurer IntelliJ IDEA de fa\u00e7on \u00e0 utiliser une version t\u00e9l\u00e9charg\u00e9e du JDK 23 ou de faire un t\u00e9l\u00e9chargement \u00e0 partir d’une liste de fournisseurs, ceci sans quitter l’IDE. Pour le niveau de langage, s\u00e9lectionnez \u00ab 23 (Preview) \u2013 Primitive types in patterns, implicitly declared classes, etc. \u00bb, comme indiqu\u00e9 dans la capture d’\u00e9cran ci-dessous :\n
\"\"<\/figure>\nPour utiliser une fonctionnalit\u00e9 de production, par exemple les commentaires de documentation Markdown, remplacez le niveau de langage par \u00ab 23 \u2013 Markdown documentation comments \u00bb, comme illustr\u00e9 dans la capture d’\u00e9cran des param\u00e8tres ci-dessous :\n
\"\"<\/figure>\nIntelliJ IDEA \u00e9tant configur\u00e9, examinons maintenant les nouvelles fonctionnalit\u00e9s du langage.\n

Types primitifs dans les motifs, instanceof et switch (fonctionnalit\u00e9 preview)<\/h2>\nSupposons que vous deviez \u00e9crire une construction conditionnelle qui ex\u00e9cute le code selon que la valeur d’une variable longue<\/code> corresponde \u00e0 plusieurs valeurs litt\u00e9rales ou se situe dans une plage de valeurs.\n\nComment feriez-vous cela ? Jusqu’\u00e0 pr\u00e9sent, on pouvait seulement utiliser une construction if\/else. Mais avec Java 23, la fonctionnalit\u00e9 preview Types primitifs dans les motifs, instanceof et switch<\/a> permet d’\u00e9crire cette fonctionnalit\u00e9 avec des constructions switch plus expressives et lisibles, utilisant des valeurs long pour les \u00e9tiquettes case.\n

Que signifie ajouter des types primitifs \u00e0 la correspondance de motifs ?<\/h3>\nAvant Java 23, les constructions switch (instructions et expressions) fonctionnaient avec des variables de r\u00e9f\u00e9rence et certains types de donn\u00e9es primitifs, comme int<\/code>, byte<\/code>, short<\/code> (avec des contraintes). De plus l’op\u00e9rateur instanceof<\/code> ne pouvait pas \u00eatre utilis\u00e9 avec les types de donn\u00e9es primitifs.\n\nAvec Java 23, vous pouvez utiliser TOUS les types de donn\u00e9es primitifs, notamment boolean<\/code>, float<\/code>, double<\/code> et long<\/code>, avec la correspondance de motifs dans les constructions switch et les op\u00e9rateurs instanceof<\/code>. Cela s’applique \u00e0 une utilisation dans les contextes imbriqu\u00e9s et de niveau sup\u00e9rieur.\n\nPourquoi devriez-vous vous int\u00e9resser \u00e0 cette fonctionnalit\u00e9 ? La valeur d’une fonctionnalit\u00e9 d\u00e9pend de la taille de la base de code concern\u00e9e et de la fr\u00e9quence d’utilisation. Les instructions conditionnelles faisant partie des bases de la programmation, il est tr\u00e8s probable que cette fonctionnalit\u00e9 soit fr\u00e9quemment utilis\u00e9e dans votre base de code. Et m\u00eame si ce n’est pas vous qui \u00e9crivez le code, vous serez amen\u00e9 \u00e0 lire le code \u00e9crit par quelqu’un d’autre.\n\nPrenons un exemple pour mieux comprendre cette fonctionnalit\u00e9.\n

Par exemple (remplacement d’instructions if-else longues par des expression switch)<\/h3>\nImaginez une m\u00e9thode, disons getHTTPCodeDesc(int)<\/code>, qui accepte un code de serveur HTTP comme valeur int et renvoie une repr\u00e9sentation sous forme de cha\u00eene correspondante, puis la v\u00e9rifie par rapport \u00e0 une valeur litt\u00e9rale ou \u00e0 une plage de valeurs.\n\nCe code semble ne pr\u00e9senter aucun probl\u00e8me a priori, nous avons d\u00e9j\u00e0 tous \u00e9crit ou lu du code similaire. Cependant, le traitement du flux des constructions if-else peut prendre plus de temps, car elles peuvent d\u00e9finir des conditions complexes qui ne sont pas limit\u00e9es \u00e0 une seule variable. Supposons que la m\u00e9thode getHTTPCodeDesc()<\/code> soit d\u00e9finie comme suit\u00a0:\n
public String getHTTPCodeDesc(int code) {\n   if (code == 100) {\n       return \"Continue\";\n   } \n   else if (code == 200) {\n       return \"OK\";\n   } \n   else if (code == 301) {\n       return \"Moved permanently\";\n   } \n   else if (code == 302) {\n       return \"Found\";\n   } \n   else if (code == 400) {\n       return \"Bad request\";\n   } \n   else if (code == 500) {\n       return \"Internal server error\";\n   } \n   else if (code == 502) {\n       return \"Bad gateway\";\n   } \n   else if (code > 100 && code  200 && code  302 && code  400 && code  502 && code < 600) {\n       return \"Server error\";\n   } \n   else {\n       return \"Unknown error\";\n   }\n}<\/pre>\nEn Java 23, le code pr\u00e9c\u00e9dent peut \u00eatre remplac\u00e9 par une expression switch (utilisant des primitifs comme motifs), de la fa\u00e7on suivante\u00a0:\n
public String getHTTPCodeDesc(int code) {\n    return switch(code) {\n        case 100 -> \"Continue\";\n        case 200 -> \"OK\";\n        case 301 -> \"Moved Permanently\";\n        case 302 -> \"Found\";\n        case 400 -> \"Bad Request\";\n        case 500 -> \"Internal Server Error\";\n        case 502 -> \"Bad Gateway\";\n        case int i when i > 100 && i  \"Informational\";\n        case int i when i > 200 && i  \"Successful\";\n        case int i when i > 302 && i  \"Redirection\";\n        case int i when i > 400 && i  \"Client Error\";\n        case int i when i > 502 && i  \"Server Error\";\n        default                            -> \"Unknown error\";\n    };\n}<\/pre>\nLe premier avantage \u00e9vident du code ci-dessus est qu’il est bien plus facile \u00e0 lire et \u00e0 comprendre que la version utilisant des instructions if-else. La logique du code est imm\u00e9diatement compr\u00e9hensible.\n\nUn autre avantage de ce code, moins \u00e9vident \u00e0 premi\u00e8re vue mais important, est qu’il r\u00e9duit la charge cognitive. La charge cognitive fait r\u00e9f\u00e9rence \u00e0 la quantit\u00e9 d\u2019informations dont vous disposez dans la m\u00e9moire de travail (l’espace de la m\u00e9moire de travail \u00e9tant limit\u00e9). Si vous essayez de surcharger votre m\u00e9moire de travail avec des instructions ou des informations sans lien direct avec votre objectif final, votre productivit\u00e9 diminue. Des extraits de code plus faciles \u00e0 lire aident \u00e0 concentrer votre attention sur d’autres aspects du code. Ce petit avantage constitue finalement une aide significative compte tenu de la fr\u00e9quence \u00e0 laquelle vous pouvez en b\u00e9n\u00e9ficier.\n\nPassons maintenant \u00e0 un sujet plus simple, \u00e0 savoir la syntaxe. Comme vous pouvez le voir, en utilisant le mod\u00e8le de type prot\u00e9g\u00e9 (quand i > 100 && i < 200<\/code>) (int i<\/code>), l’\u00e9tiquette case prot\u00e9g\u00e9e peut avoir une valeur constante (comme 100, 200, etc.) ou une plage de valeurs sp\u00e9cifi\u00e9e \u00e0 l’aide de la correspondance de motifs. Vous pouvez \u00e9galement d\u00e9finir une clause default<\/code>.\n\nDans le code pr\u00e9c\u00e9dent, la m\u00e9thode getHTTPCodeDesc()<\/code> renvoie une valeur en utilisant l’expression switch. Quelle que soit la valeur que vous passez au param\u00e8tre de m\u00e9thode, c’est-\u00e0-dire code<\/code> dans notre exemple, la m\u00e9thode doit renvoyer une valeur. En d’autres termes, l’expression switch doit \u00eatre exhaustive. Dans le cas contraire, IntelliJ IDEA est capable de le d\u00e9tecter et sugg\u00e8re l’ajout de la clause default<\/code>, comme dans le GIF suivant\u00a0:\n
\"\"<\/figure>\nLe code pr\u00e9c\u00e9dent active une variable de type int. De m\u00eame, vous pouvez activer des variables pour tous les autres types primitifs, tels que long, double, float, etc.\n
Vous ne connaissez pas bien la correspondance de motifs ou les modifications r\u00e9centes de la construction switch ?<\/h3>\nJe vous invite \u00e0 consulter la section consacr\u00e9e aux bases<\/a> de la correspondance de motifs dans mon article Java 17 et IntelliJ IDEA<\/a>. Et si vous souhaitez en savoir plus sur la facon dont la correspondance de motifs est utilis\u00e9e dans les constructions switch, j’ai aussi \u00e9crit un article d\u00e9taill\u00e9 sur ce sujet, Evolution of the Switch Construct in Java\u2014Why Should you Care?<\/a>, dans lequel j’explique comment les constructions switch utilisent la correspondance de motifs pour v\u00e9rifier les valeurs de r\u00e9f\u00e9rence par rapport \u00e0 diff\u00e9rents motifs et pour ex\u00e9cuter le code de mani\u00e8re conditionnelle selon le type de variable et ses attributs.\n
Utilisation du filtrage par motif avec les valeurs bool\u00e9ennes<\/h3>\nIl est fr\u00e9quent de lire et d’\u00e9crire du code dont la sortie varie selon qu’une variable bol\u00e9enne<\/code> a la valeur true<\/code> ou false<\/code>. Par exemple, dans le code suivant, la m\u00e9thode calculateDiscount<\/code> calcule et renvoie une valeur de r\u00e9duction (discount) diff\u00e9rente selon que vous passez true<\/code> ou false<\/code> au param\u00e8tre de m\u00e9thode isPremiumMember<\/code>\u00a0:\n
public class DiscountCalculator {\n    private static final int PREMIUM_DISCOUNT_PERCENTAGE = 20;\n    private static final int REGULAR_DISCOUNT_PERCENTAGE = 5;\n\n    public int calculateDiscount(boolean isPremiumMember, int totalAmount) {\n        int discount;\n        if (isPremiumMember) {\n            \/\/ Calculate discount for premium members\n            discount = (totalAmount * PREMIUM_DISCOUNT_PERCENTAGE) \/ 100;\n        } else {\n            \/\/ Calculate discount for regular members\n            discount = (totalAmount * REGULAR_DISCOUNT_PERCENTAGE) \/ 100;\n        }\n        return discount;\n    }\n}<\/pre>\nAu lieu d’utiliser une construction if-else, vous pouvez changer la valeur du param\u00e8tre de la m\u00e9thode bool\u00e9ene isPremiumMember<\/code> sans que la d\u00e9finition de la variable locale discount<\/code> ne soit requise, comme ci-dessous\u00a0:\n
public int calculateDiscount(boolean isPremiumMember, int totalAmount) {\n    return switch (isPremiumMember) {\n        case true -> (totalAmount * PREMIUM_DISCOUNT_PERCENTAGE) \/ 100;\n        case false -> (totalAmount * REGULAR_DISCOUNT_PERCENTAGE) \/ 100;\n    };\n}<\/pre>\nL’expression switch dans la m\u00e9thode calculateDiscount()<\/code> \u00e9tant exhaustive, s’il vous manque l’une des valeurs true ou false, IntelliJ IDEA peut le d\u00e9tecter et vous sugg\u00e8rera d’ins\u00e9rer une valeur par d\u00e9faut ou la casse true\/false manquante, comme le montre le GIF suivant\u00a0:\n
\"\"<\/figure>\n
Utilisation des types primitifs avec l’op\u00e9rateur instanceof<\/h3>\nAvant Java 23, aucun type primitif ne pouvait \u00eatre utilis\u00e9 avec l’op\u00e9rateur instanceof.\n\nL’op\u00e9rateur instanceof peut \u00eatre utilis\u00e9 pour v\u00e9rifier le type d’une variable et ex\u00e9cuter le code de fa\u00e7on conditionnelle. En utilisant la correspondance de motifs pour instanceof, vous pouvez \u00e9galement d\u00e9clarer et initialiser les variables de motifs si le type de la variable \u00e0 comparer correspond au motif de type, ce sans avoir besoin d’une conversion de type explicite. La variable instanceof peut \u00e9galement utiliser des motifs de garde.\n\nAvec l’ajout de types primitifs \u00e0 l’op\u00e9rateur instanceof, vous pouvez d\u00e9finir du code comme ci-dessous\u00a0:\n
import static java.io.IO.println;\n\nvoid main() {\n    var weight = 68;\n    if (weight instanceof byte byteWeight && byteWeight <= 70) {\n        println(\"Weight less than 70\");\n    }\n}<\/pre>\nNotez que la fonctionnalit\u00e9 Implicitly declared classes and instance main method de Java 23 d\u00e9finit java.io.IO<\/code> avec des m\u00e9thodes statiques, ce qui vous permet de l’importer et d’utiliser println()<\/code> pour renvoyer des valeurs \u00e0 la console au lieu d’utiliser System.out.println()<\/code>.\n\nSi vous envisagez de v\u00e9rifier plusieurs types et conditions, vous pouvez utiliser une construction switch avec garde, comme ci-dessous\u00a0:\n
var weight = 68;\n\nswitch (weight) {\n    case byte b when b  println(\"byte: less than 70\");\n    case int i  when i  println(\"int: less than 7000\");\n    case long l when l >= 7_000 && l  println(\"long range: 7_000 - 70_000\");\n    case double d                               -> println(\"double\");\n}<\/pre>\n
Conversion s\u00fbre entre les types de donn\u00e9es<\/h3>\nLorsque vous utilisez la correspondance de motifs avec des types de donn\u00e9es primitifs, le compilateur Java assure qu’il n’y ait pas de perte d’informations. Dans l’exemple suivant, l’op\u00e9rateur instanceof peut effectuer la conversion entre les types de donn\u00e9es double et byte lorsqu’il d\u00e9tecte que cela ne posera aucun probl\u00e8me\u00a0:\n
double height = 67;\n\nif (height instanceof byte byteHeight)\n    System.out.println(byteHeight);<\/pre>\nDu code similaire ne s’ex\u00e9cuterait pas sans un op\u00e9rateur instanceof. Le code suivant ne sera pas compil\u00e9 :\n
double height = 67;\n\nfinal byte convertToByte = height;<\/pre>\n
Analyse robuste du flux de donn\u00e9es dans IntelliJ IDEA<\/h3>\nIntelliJ IDEA fournit une prise en charge robuste pour les types primitifs dans les instructions switch et int\u00e8gre \u00e9galement une analyse avanc\u00e9e du flux de donn\u00e9es afin d’aider les d\u00e9veloppeurs \u00e0 \u00e9viter les probl\u00e8mes les plus courants. Comme le montre l’exemple suivant, l’analyse du flux de donn\u00e9es dans IntelliJ IDEA permet de d\u00e9terminer que la deuxi\u00e8me \u00e9tiquette case, \u00e0 savoir case int _, et le reste des \u00e9tiquettes case ne sont pas atteignables, le code sortant de la m\u00e9thode si la valeur de la variable weight est sup\u00e9rieure \u00e0 70. IntelliJ IDEA vous signale le code inaccessible et vous fournit des suggestions appropri\u00e9es :\n
\"\"<\/figure>\n
Records et composants des types de donn\u00e9es primitifs<\/h3>\nSupposons que vous d\u00e9finissiez un record Person de la fa\u00e7on suivante\u00a0:\n
record Person(String name, double weight) {}<\/pre>\nJusqu’\u00e0 pr\u00e9sent, vous pouviez le d\u00e9composer en types de donn\u00e9es exacts. Cependant, les types primitifs dans les correspondances de motifs permettent d’utiliser d’autres types de donn\u00e9es compatibles, tels que int, long, etc. Voici un exemple\u00a0:\n
Person person = new Person(\"Java\", 672);\n\nswitch (person) {\n    case Person(String name, byte weight) -> println(\"byte:\" + weight);\n    case Person(String name, int weight) -> println(\"int:\"  + weight);\n    case Person(String name, double weight) -> println(\"double:\" + weight);\n    case Person(String name, long weight) -> println(\"long:\" + weight);\n    default -> throw new IllegalStateException(\"Unexpected value: \" + person);\n}<\/pre>\nVous pouvez aussi l’utiliser avec l’op\u00e9rateur instanceof, de la fa\u00e7on suivante\u00a0:\n
 if (person instanceof Person(String name, byte weight)) {\n     System.out.println(\"Instanceof : \" + weight);\n }<\/pre>\n
Ce qui est pr\u00e9vu dans IntelliJ IDEA pour la prise en charge de cette fonctionnalit\u00e9<\/h3>\nLe renforcement de la prise en charge des types de donn\u00e9es primitifs dans la correspondance de motifs est en cours et inclut la possibilit\u00e9 d’utiliser l’op\u00e9rateur postfix .switch sur tous les types de donn\u00e9es primitifs pour commencer \u00e0 \u00e9crire une construction switch. Il sera \u00e9galement possible de convertir une instruction if-else existante en construction switch utilisant des types de donn\u00e9es primitifs, ce qui facilitera consid\u00e9rablement l’adoption de cette nouvelle fonctionnalit\u00e9.\n
Commentaires de documentation Markdown (fonctionnalit\u00e9 de production)<\/h2>\nJusqu’\u00e0 maintenant, les commentaires de documentation Java \u00e9taient \u00e9crits avec des balises HTML et JavaDoc. Avec la nouvelle fonctionnalit\u00e9 Documentation comments, vous pourrez \u00e9galement utiliser Markdown pour \u00e9crire des commentaires JavaDoc. Avec Java 23, il s’agit d’une fonctionnalit\u00e9 de production.\n\nVous vous demandez peut-\u00eatre quelle est la raison de ce changement ?\n\nL’une des raisons est que le HTML, qui \u00e9tait un tr\u00e8s bon choix au moment de l’introduction de Java \u00e0 la fin des ann\u00e9es 90, n’est plus tr\u00e8s populaire chez les jeunes d\u00e9veloppeurs. L’\u00e9criture manuelle de HTML n’est pas simple. Markdown est plus simple \u00e0 \u00e9crire et \u00e0 lire, et peut \u00eatre facilement converti en code HTML. De nombreux d\u00e9veloppeurs utilisent maintenant Markdown pour documenter leur code, \u00e9crire des contenus tels que des articles et g\u00e9n\u00e9rer des pages de sites web, entre autres.\n\nNous allons voir comment vous pouvez utiliser Markdown pour \u00e9crire des commentaires Javadoc dans votre fichier de code source et comment IntelliJ IDEA peut vous y aider.\n
Un exemple<\/h3>\nLes commentaires de documentation Markdown commencent par \/\/\/.\n\nLe choix des trois barres obliques inverses est int\u00e9ressant. Jonathan Gibbons, responsable de cette fonctionnalit\u00e9 chez Oracle, indique que modifier la syntaxe des fonctionnalit\u00e9s du langage Java n’est pas une t\u00e2che facile. Les commentaires multilignes commencent par \/* et se terminent par *\/, ce qui rend difficile d’ins\u00e9rer dans la documentation du code qui incluerait *\/. C’est pourquoi les commentaires de documentation Markdown commencent par \/\/\/.\n\nL’ancienne fa\u00e7on d’\u00e9crire des commentaires de documentation, avec des balises HTML et JavaDoc, est \u00e9galement prise en charge. Jonathan mentionne aussi qu’il n’est pas possible de convertir des balises JavaDoc en un \u00e9quivalent en Markdown. Les d\u00e9veloppeurs peuvent donc utiliser une combinaison de commentaires Markdown et de balises JavaDoc pour b\u00e9n\u00e9ficier des avantages de chacune de ces approches.\n\nVoici un exemple d’utilisation de balises Markdown et Javadoc pour documenter une m\u00e9thode\u00a0:\n
\/\/\/\n\/\/\/ **Getting started and having fun learning Java :)**\n\/\/\/\n\/\/\/ Prints a pattern of the letter 'P' using the specified character.\n\/\/\/\n\/\/\/ @param size the size of the pattern\n\/\/\/ @param charToPrint the character to use for the pattern\n\/\/\/\nprivate void printP(int size, char charToPrint) {\n    for (int i = 0; i < size; i++) {\n        for (int j = 0; j < size; j++) {\n            if (j == 0 || (i == 0 || i == size \/ 2) && j < size - 1 || (j == size - 1 && i <= size \/ 2)) {\n                System.out.print(charToPrint + \" \");\n            } else {\n                System.out.print(\"  \");\n            }\n        }\n        System.out.println();\n    }\n}<\/pre>\nIntelliJ IDEA vous aide \u00e0 passer d’une vue \u00e0 l’autre dans l’\u00e9diteur et \u00e0 v\u00e9rifier comment les commentaires de documentation appara\u00eetraient pour leurs lecteurs potentiels.\n
Visualiser les commentaires de documentation Java dans IntelliJ IDEA<\/h3>\nJonathan Gibbons, responsable de la JEP \u00ab Markdown Documentation Comments \u00bb insiste sur la n\u00e9cessit\u00e9 pour tous les d\u00e9veloppeurs de v\u00e9rifier que les commentaires de documentation Java qu’ils ont ajout\u00e9s \u00e0 leur base de code sont corrects.\n\nIntelliJ IDEA fournit un \u00ab\u00a0mode Lecteur\u00a0\u00bb qui vous permet de visualiser les commentaires de documentation Java dans votre code source. Vous pouvez aussi basculer entre les commentaires de documentation relatifs au code Java et la vue de la fa\u00e7on dont est affich\u00e9e la documentation en utilisant la fonctionnalit\u00e9 \u00ab\u00a0Toggle Rendered View\u00a0\u00bb, comme dans le GIF suivant\u00a0:\n
\"\"<\/figure>\n
\u00c9crire des commentaires de documentation Markdown dans IntelliJ IDEA<\/h3>\nIntelliJ IDEA est capable de d\u00e9tecter l’utilisation de Markdown pour documenter une m\u00e9thode. Lorsque vous commencez par \/\/\/ et appuyez sur Entr\u00e9e, il ajoute \/\/\/ sur la ligne suivante, comme illustr\u00e9 dans le GIF suivant\u00a0:\n
\"\"<\/figure>\n
Devez-vous convertir vos commentaires de documentation existants pour utiliser Markdown ?<\/h3>\nVoici un GIF montrant la documentation de la m\u00e9thode hashCode \u00e9crite avec Markdown dans IntelliJ IDEA. En s\u00e9lectionnant \u00ab\u00a0Toggle Rendered View\u00a0\u00bb vous pouvez facilement visualiser la documentation dans la vue Lecteur, ce qui facilite la lecture et la compr\u00e9hension.\n
\"\"<\/figure>\nDans l’id\u00e9al, je d\u00e9conseille de convertir votre documentation existante pour utiliser Markdown, sauf si vos d\u00e9veloppeurs ou utilisateurs d’API rencontrent des probl\u00e8mes de lisibilit\u00e9 majeurs lorsqu’ils consultent votre base de code (API, biblioth\u00e8ques, framework) en utilisant des outils n’offrant pas de vue alternative, contrairement \u00e0 IntelliJ IDEA.\n
D\u00e9clarations d’importation de module (fonctionnalit\u00e9 preview)<\/h1>\nCette fonctionnalit\u00e9 permet d’importer une biblioth\u00e8que de modules comme l’API Java dans votre classe ou interface en utilisant une seule instruction, telle qu’import module java.base, qui importera tous les paquets qui sont export\u00e9s par le module java.base.\n\nVous n’avez pas besoin d’instructions d’importation distinctes pour importer des paquets tels que java.util ou java.io dans votre classe, car ils sont export\u00e9s par java.base.\n
Exemple<\/h3>\nL’exemple de code suivant utilise les classes des paquets java.io et java.util. En incluant l’instruction \u00ab\u00a0import java.base\u00a0\u00bb, vous n’avez pas besoin d’importer les paquets java.io et java.util individuellement, car ils sont export\u00e9s par le module java.base\u00a0:\n
import module java.base;\npublic class ImportModuleHelloWorld {\n\n    public static void main(String[] args) {\n\n        try {\n            InputStream inputStream = new BufferedInputStream(\n                                            new FileInputStream(\n                                                   new File(\"abc.txt\")));\n        } catch (FileNotFoundException e) {\n            throw new RuntimeException(e);\n        }\n\n        Map list = new HashMap();\n    }\n}<\/pre>\nCependant, si vous supprimez l’instruction d’importation de module de la partie sup\u00e9rieure, IntelliJ IDEA importera des classes et des interfaces individuelles depuis les paquets java.io et java.util. Vous pouvez voir cela dans le GIF suivant\u00a0:\n
\"\"<\/figure>\n
Quels paquets sont export\u00e9s par le module java.base (ou d’autres modules) ?<\/h3>\nLa r\u00e9ponse \u00e0 cette question est simple lorsqu’on utilise IntelliJ IDEA. Cliquez sur le nom du module dans l’\u00e9diteur ou utilisez le raccourci correspondant (Go to Declaration ou Usages) afin de pouvoir visualiser la d\u00e9finition de ce module et d’identifier tous les modules qu’il exporte. Vous pouvez voir cela dans le GIF suivant\u00a0:\n
\"\"<\/figure>\n
Classes d\u00e9clar\u00e9es implicites et m\u00e9thodes d’instance Main (troisi\u00e8me preview)<\/h2>\nIntroduite en tant que fonctionnalit\u00e9 preview avec Java 21, cette fonctionnalit\u00e9<\/a> en est \u00e0 sa troisi\u00e8me preview avec Java 23.\n\nElle est l\u00e0 pour changer la fa\u00e7on dont les nouveaux d\u00e9veloppeurs commencent \u00e0 apprendre Java. Elle simplifie les \u00e9tapes initiales pour les \u00e9tudiants qui comment \u00e0 apprendre les bases du langage, telles que l’affectation des variables, les s\u00e9quences, les conditions et l’it\u00e9ration. Ils n’ont ainsi plus \u00e0 d\u00e9clarer une classe explicite pour d\u00e9velopper leur code, ni \u00e0 \u00e9crire leur m\u00e9thode main() avec la signature public static void main(String []). Avec cette fonctionnalit\u00e9, les classes peuvent \u00eatre d\u00e9clar\u00e9es de fa\u00e7on implicite et la m\u00e9thode main()<\/em> peut \u00eatre cr\u00e9\u00e9e avec un nombre de mots-cl\u00e9s moins important.\n\nSi vous d\u00e9couvrez cette fonctionnalit\u00e9, je vous invite \u00e0 consulter mon article \u2018HelloWorld\u2019 and \u2018main()\u2019 meet minimalistic<\/a> pour en savoir plus. Dans cette section, je vais \u00e9voquer les ajouts faits \u00e0 cette fonctionnalit\u00e9 en Java 23.\n
Utiliser des paquets export\u00e9s par le module java.base sans les importer explicitement<\/h3>\nEn incluant une seule d\u00e9claration d’importation, \u00e0 savoir import module java.base, en haut de votre classe implicite, vous pouvez importer automatiquement les paquets export\u00e9s par java.base. Votre classe implicite n’a plus besoin d’instructions d’importation individuelles pour ces classes ou paquets, comme le montre le GIF suivant :\n
\"\"<\/figure>\n
Simplifier l’\u00e9criture du code pour interagir avec la console<\/h3>\nInteraction avec la console\u00a0: l’impression ou la consommation de messages est l’une des actions les plus fr\u00e9quemment utilis\u00e9es par les nouveaux d\u00e9veloppeurs Java. Cela a \u00e9t\u00e9 encore simplifi\u00e9 avec cette fonctionnalit\u00e9.\n\nLes classes que vous avez d\u00e9clar\u00e9es implicitement peuvent utiliser les m\u00e9thodes println() et print() pour afficher des messages sur la console et la m\u00e9thode readln() pour lire des messages sous forme de cha\u00eene sans les importer explicitement dans votre classe. Toutes ces m\u00e9thodes sont d\u00e9clar\u00e9es dans une nouvelle classe de niveau sup\u00e9rieur, java.io.IO<\/a>, qui est import\u00e9e implicitement par les classes implicites.\n\nLa fa\u00e7on dont vous devez les importer explicitement dans une classe normale est illustr\u00e9e dans le GIF suivant :\n\n\n\nLe GIF montre que vous n’avez pas besoin d’importations explicites lorsque vous utilisez les m\u00eames m\u00e9thodes pr\u00e9c\u00e9dentes dans une classe implicite\u00a0:\n\n\n
Corps de constructeur flexibles (deuxi\u00e8me preview)<\/h1>\nIl s’agit de la deuxi\u00e8me preview d’une fonctionnalit\u00e9 du JDK 22, appel\u00e9e auparavant \u00ab Statements before super() \u00bb. Au-del\u00e0 de ce changement de nom, cette fonctionnalit\u00e9 a fait l’objet d’une modification importante. Il est d\u00e9sormais possible d’initialiser les champs avant d’appeler super() ou this(), ce qui s’av\u00e8re utile lorsqu’une superclasse appelle une m\u00e9thode depuis son constructeur et que vous voulez remplacer cette m\u00e9thode dans une sous-classe et acc\u00e9der \u00e0 un champ depuis la sous-classe dans cette m\u00e9thode. Auparavant, le champ subclass n’\u00e9tait pas initialis\u00e9 lorsque la m\u00e9thode \u00e9tait appel\u00e9e depuis le constructeur superclass. Il est d\u00e9sormais possible d’initialiser le champ et d’\u00e9viter les surprises. Voici un exemple de code illustrant cette fonctionnalit\u00e9 :\n
abstract class Action {\n    public Action() {\n        System.out.println(\"performing \" + getText());\n    }\n    public abstract String getText();\n}\n\nclass DoubleAction extends Action {\n    private final String text;\n    private DoubleAction(String text) {\n        this.text = text; \/\/ this did not compile before Java 23 with preview features enabled.\n        super();\n    }\n\n    @Override public String getText() {\n        return text + text;\n    }\n}<\/pre>\nSi vous d\u00e9couvrez cette fonctionnalit\u00e9, je vous invite \u00e0 consulter l’article que je lui ai consacr\u00e9, qui explique pourquoi et comment l’utiliser : https:\/\/blog.jetbrains.com\/idea\/2024\/02\/constructor-makeover-in-java-22\/<\/a>.\n
Fonctionnalit\u00e9s preview<\/h2>\n\n\n\n\nLes fonctionnalit\u00e9s pr\u00e9sent\u00e9es dans cet article, \u00ab types primitifs dans les motifs, instanceof et switch \u00bb, \u00ab d\u00e9clarations d’importation de module \u00bb, \u00ab classes d\u00e9clar\u00e9es implicitement et m\u00e9thodes d’instance main \u00bb et \u00ab corps de constructeur flexibles \u00bb, sont toutes des fonctionnalit\u00e9s preview en Java 23. Avec un nouveau cycle de publication de six mois, les nouvelles fonctionnalit\u00e9s du langage sont fournies en version preview. Elles peuvent \u00eatre r\u00e9introduites ult\u00e9rieurement dans les versions de Java en tant que seconde preview ou plus, avec ou sans modifications. Une fois qu’elles sont suffisamment stables, elles peuvent \u00eatre ajout\u00e9es \u00e0 Java en tant que fonctionnalit\u00e9 standard du langage.\n\n\n\n\n\nLes fonctionnalit\u00e9s preview du langage sont compl\u00e8tes, mais pas permanentes, ce qui signifie essentiellement qu’elles sont pr\u00eates \u00e0 \u00eatre utilis\u00e9es par des d\u00e9veloppeurs, m\u00eame si certains d\u00e9tails peuvent \u00e9voluer au fil des nouvelles versions de Java sur la base des retours des d\u00e9veloppeurs. Contrairement \u00e0 une API, les fonctionnalit\u00e9s de langage ne peuvent plus devenir obsol\u00e8tes. Par cons\u00e9quent, si vous avez des commentaires sur l’une des versions preview des fonctionnalit\u00e9s du langage, n’h\u00e9sitez pas \u00e0 les partager via la mailing list de JDK (inscription gratuite requise).\n\n\n\n\n\nEn raison du mode de fonctionnement de ces fonctionnalit\u00e9s, IntelliJ IDEA ne prend en charge que les fonctionnalit\u00e9s preview de la version actuelle de JDK. Les fonctionnalit\u00e9s en mode preview du langage peuvent varier selon les versions de Java, jusqu’\u00e0 ce qu’elles soient abandonn\u00e9es ou ajout\u00e9es en tant que fonctionnalit\u00e9s standard. Le code utilisant une fonctionnalit\u00e9 preview d’une version plus ancienne de Java SE Platform risque de pas \u00eatre compil\u00e9 ou ex\u00e9cut\u00e9 sur une version plus r\u00e9cente.\n
R\u00e9sum\u00e9<\/h2>\nDans cet article de blog j’ai couvert cinq fonctionnalit\u00e9s Java 23\u00a0: types primitifs dans les motifs, instanceof et switch<\/a>, commentaires de documentation Markdown<\/a>, d\u00e9clarations d’importation de module<\/a>, classes d\u00e9clar\u00e9es implicites et m\u00e9thodes d’instance main<\/a> et corps de constructeur flexibles<\/a>.\n\nJe vous invite \u00e0 les essayer pour d\u00e9couvrir comment elles peuvent vous aider \u00e0 am\u00e9liorer vos applications.\n\nBon d\u00e9veloppement\u00a0!","protected":false},"author":813,"featured_media":510392,"comment_status":"closed","ping_status":"closed","template":"","categories":[4759,5088],"tags":[3374,155,8568,76,8582],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/519757"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/types\/idea"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/users\/813"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/comments?post=519757"}],"version-history":[{"count":9,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/519757\/revisions"}],"predecessor-version":[{"id":610142,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/idea\/519757\/revisions\/610142"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media\/510392"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/media?parent=519757"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/categories?post=519757"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/tags?post=519757"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/fr\/wp-json\/wp\/v2\/cross-post-tag?post=519757"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}