IntelliJ IDEA Java

Java 23 et IntelliJ IDEA

Les nouveautés introduites par Java 23 concernent les fonctionnalités du langage, l’API principale et la JVM, et présentent un intérêt tant pour les débutants que pour les développeurs expérimentés. La version 2024.2 d’IntelliJ IDEA fournit une prise en charge des fonctionnalités de Java 23. Il n’est pas toujours évident de suivre le rythme des publications des nouvelles versions de Java et de savoir tout ce qui a changé, pourquoi, et comment tirer parti de ses dernières mises à jour et nouvelles fonctionnalités. Dans cet article, je présente les principales nouveautés et mises à jour de fonctionnalités de Java 23, notamment en termes de syntaxe et de sémantique, ainsi que les points particuliers pour lesquels elles facilitent le travail des développeurs, tout en expliquant comment IntelliJ IDEA peut vous aider à les utiliser au mieux. J’ai choisi de parler plus particulièrement des types de données primitifs dans la correspondance de motifs, de la capacité d’importer des modules dans les bases de code, de la possibilité d’utiliser Markdown dans les commentaires de la documentation, des classes déclarées implicitement et des méthodes d’instance main et des corps de constructeur flexibles. Si cela vous intéresse, la liste de toutes les fonctionnalités de Java 23 est disponible ici. Avant d’examiner les fonctionnalités de Java 23, commençons par voir configurer rapidement IntelliJ IDEA.

Configuration d’IntelliJ IDEA

La prise en charge de Java 23 est disponible dans la version majeure la plus récente d’IntelliJ IDEA. Commencez par définir le SDK sur Java 23 dans Project Settings. Vous pouvez choisir de configurer IntelliJ IDEA de façon à utiliser une version téléchargée du JDK 23 ou de faire un téléchargement à partir d’une liste de fournisseurs, ceci sans quitter l’IDE. Pour le niveau de langage, sélectionnez « 23 (Preview) – Primitive types in patterns, implicitly declared classes, etc. », comme indiqué dans la capture d’écran ci-dessous :

Pour utiliser une fonctionnalité de production, par exemple les commentaires de documentation Markdown, remplacez le niveau de langage par « 23 – Markdown documentation comments », comme illustré dans la capture d’écran des paramètres ci-dessous :

IntelliJ IDEA étant configuré, examinons maintenant les nouvelles fonctionnalités du langage.

Types primitifs dans les motifs, instanceof et switch (fonctionnalité preview)

Supposons que vous deviez écrire une construction conditionnelle qui exécute le code selon que la valeur d’une variable longue corresponde à plusieurs valeurs littérales ou se situe dans une plage de valeurs. Comment feriez-vous cela ? Jusqu’à présent, on pouvait seulement utiliser une construction if/else. Mais avec Java 23, la fonctionnalité preview Types primitifs dans les motifs, instanceof et switch permet d’écrire cette fonctionnalité avec des constructions switch plus expressives et lisibles, utilisant des valeurs long pour les étiquettes case.

Que signifie ajouter des types primitifs à la correspondance de motifs ?

Avant Java 23, les constructions switch (instructions et expressions) fonctionnaient avec des variables de référence et certains types de données primitifs, comme int, byte, short (avec des contraintes). De plus l’opérateur instanceof ne pouvait pas être utilisé avec les types de données primitifs. Avec Java 23, vous pouvez utiliser TOUS les types de données primitifs, notamment boolean, float, double et long, avec la correspondance de motifs dans les constructions switch et les opérateurs instanceof. Cela s’applique à une utilisation dans les contextes imbriqués et de niveau supérieur. Pourquoi devriez-vous vous intéresser à cette fonctionnalité ? La valeur d’une fonctionnalité dépend de la taille de la base de code concernée et de la fréquence d’utilisation. Les instructions conditionnelles faisant partie des bases de la programmation, il est très probable que cette fonctionnalité soit fréquemment utilisée dans votre base de code. Et même si ce n’est pas vous qui écrivez le code, vous serez amené à lire le code écrit par quelqu’un d’autre. Prenons un exemple pour mieux comprendre cette fonctionnalité.

Par exemple (remplacement d’instructions if-else longues par des expression switch)

Imaginez une méthode, disons getHTTPCodeDesc(int), qui accepte un code de serveur HTTP comme valeur int et renvoie une représentation sous forme de chaîne correspondante, puis la vérifie par rapport à une valeur littérale ou à une plage de valeurs. Ce code semble ne présenter aucun problème a priori, nous avons déjà tous écrit ou lu du code similaire. Cependant, le traitement du flux des constructions if-else peut prendre plus de temps, car elles peuvent définir des conditions complexes qui ne sont pas limitées à une seule variable. Supposons que la méthode getHTTPCodeDesc() soit définie comme suit :

public String getHTTPCodeDesc(int code) {
   if (code == 100) {
       return "Continue";
   } 
   else if (code == 200) {
       return "OK";
   } 
   else if (code == 301) {
       return "Moved permanently";
   } 
   else if (code == 302) {
       return "Found";
   } 
   else if (code == 400) {
       return "Bad request";
   } 
   else if (code == 500) {
       return "Internal server error";
   } 
   else if (code == 502) {
       return "Bad gateway";
   } 
   else if (code > 100 && code  200 && code  302 && code  400 && code  502 && code < 600) {
       return "Server error";
   } 
   else {
       return "Unknown error";
   }
}

En Java 23, le code précédent peut être remplacé par une expression switch (utilisant des primitifs comme motifs), de la façon suivante :

public String getHTTPCodeDesc(int code) {
    return switch(code) {
        case 100 -> "Continue";
        case 200 -> "OK";
        case 301 -> "Moved Permanently";
        case 302 -> "Found";
        case 400 -> "Bad Request";
        case 500 -> "Internal Server Error";
        case 502 -> "Bad Gateway";
        case int i when i > 100 && i  "Informational";
        case int i when i > 200 && i  "Successful";
        case int i when i > 302 && i  "Redirection";
        case int i when i > 400 && i  "Client Error";
        case int i when i > 502 && i  "Server Error";
        default                            -> "Unknown error";
    };
}

Le premier avantage évident du code ci-dessus est qu’il est bien plus facile à lire et à comprendre que la version utilisant des instructions if-else. La logique du code est immédiatement compréhensible. Un autre avantage de ce code, moins évident à première vue mais important, est qu’il réduit la charge cognitive. La charge cognitive fait référence à la quantité d’informations dont vous disposez dans la mémoire de travail (l’espace de la mémoire de travail étant limité). Si vous essayez de surcharger votre mémoire de travail avec des instructions ou des informations sans lien direct avec votre objectif final, votre productivité diminue. Des extraits de code plus faciles à lire aident à concentrer votre attention sur d’autres aspects du code. Ce petit avantage constitue finalement une aide significative compte tenu de la fréquence à laquelle vous pouvez en bénéficier. Passons maintenant à un sujet plus simple, à savoir la syntaxe. Comme vous pouvez le voir, en utilisant le modèle de type protégé (quand i > 100 && i < 200) (int i), l’étiquette case protégée peut avoir une valeur constante (comme 100, 200, etc.) ou une plage de valeurs spécifiée à l’aide de la correspondance de motifs. Vous pouvez également définir une clause default. Dans le code précédent, la méthode getHTTPCodeDesc() renvoie une valeur en utilisant l’expression switch. Quelle que soit la valeur que vous passez au paramètre de méthode, c’est-à-dire code dans notre exemple, la méthode doit renvoyer une valeur. En d’autres termes, l’expression switch doit être exhaustive. Dans le cas contraire, IntelliJ IDEA est capable de le détecter et suggère l’ajout de la clause default, comme dans le GIF suivant :

Le code précédent active une variable de type int. De même, vous pouvez activer des variables pour tous les autres types primitifs, tels que long, double, float, etc.

Vous ne connaissez pas bien la correspondance de motifs ou les modifications récentes de la construction switch ?

Je vous invite à consulter la section consacrée aux bases de la correspondance de motifs dans mon article Java 17 et IntelliJ IDEA. Et si vous souhaitez en savoir plus sur la facon dont la correspondance de motifs est utilisée dans les constructions switch, j’ai aussi écrit un article détaillé sur ce sujet, Evolution of the Switch Construct in Java—Why Should you Care?, dans lequel j’explique comment les constructions switch utilisent la correspondance de motifs pour vérifier les valeurs de référence par rapport à différents motifs et pour exécuter le code de manière conditionnelle selon le type de variable et ses attributs.

Utilisation du filtrage par motif avec les valeurs booléennes

Il est fréquent de lire et d’écrire du code dont la sortie varie selon qu’une variable boléenne a la valeur true ou false. Par exemple, dans le code suivant, la méthode calculateDiscount calcule et renvoie une valeur de réduction (discount) différente selon que vous passez true ou false au paramètre de méthode isPremiumMember :

public class DiscountCalculator {
    private static final int PREMIUM_DISCOUNT_PERCENTAGE = 20;
    private static final int REGULAR_DISCOUNT_PERCENTAGE = 5;

    public int calculateDiscount(boolean isPremiumMember, int totalAmount) {
        int discount;
        if (isPremiumMember) {
            // Calculate discount for premium members
            discount = (totalAmount * PREMIUM_DISCOUNT_PERCENTAGE) / 100;
        } else {
            // Calculate discount for regular members
            discount = (totalAmount * REGULAR_DISCOUNT_PERCENTAGE) / 100;
        }
        return discount;
    }
}

Au lieu d’utiliser une construction if-else, vous pouvez changer la valeur du paramètre de la méthode booléene isPremiumMember sans que la définition de la variable locale discount ne soit requise, comme ci-dessous :

public int calculateDiscount(boolean isPremiumMember, int totalAmount) {
    return switch (isPremiumMember) {
        case true -> (totalAmount * PREMIUM_DISCOUNT_PERCENTAGE) / 100;
        case false -> (totalAmount * REGULAR_DISCOUNT_PERCENTAGE) / 100;
    };
}

L’expression switch dans la méthode calculateDiscount() étant exhaustive, s’il vous manque l’une des valeurs true ou false, IntelliJ IDEA peut le détecter et vous suggèrera d’insérer une valeur par défaut ou la casse true/false manquante, comme le montre le GIF suivant :

Utilisation des types primitifs avec l’opérateur instanceof

Avant Java 23, aucun type primitif ne pouvait être utilisé avec l’opérateur instanceof. L’opérateur instanceof peut être utilisé pour vérifier le type d’une variable et exécuter le code de façon conditionnelle. En utilisant la correspondance de motifs pour instanceof, vous pouvez également déclarer et initialiser les variables de motifs si le type de la variable à comparer correspond au motif de type, ce sans avoir besoin d’une conversion de type explicite. La variable instanceof peut également utiliser des motifs de garde. Avec l’ajout de types primitifs à l’opérateur instanceof, vous pouvez définir du code comme ci-dessous :

import static java.io.IO.println;

void main() {
    var weight = 68;
    if (weight instanceof byte byteWeight && byteWeight <= 70) {
        println("Weight less than 70");
    }
}

Notez que la fonctionnalité Implicitly declared classes and instance main method de Java 23 définit java.io.IO avec des méthodes statiques, ce qui vous permet de l’importer et d’utiliser println() pour renvoyer des valeurs à la console au lieu d’utiliser System.out.println(). Si vous envisagez de vérifier plusieurs types et conditions, vous pouvez utiliser une construction switch avec garde, comme ci-dessous :

var weight = 68;

switch (weight) {
    case byte b when b  println("byte: less than 70");
    case int i  when i  println("int: less than 7000");
    case long l when l >= 7_000 && l  println("long range: 7_000 - 70_000");
    case double d                               -> println("double");
}

Conversion sûre entre les types de données

Lorsque vous utilisez la correspondance de motifs avec des types de données primitifs, le compilateur Java assure qu’il n’y ait pas de perte d’informations. Dans l’exemple suivant, l’opérateur instanceof peut effectuer la conversion entre les types de données double et byte lorsqu’il détecte que cela ne posera aucun problème :

double height = 67;

if (height instanceof byte byteHeight)
    System.out.println(byteHeight);

Du code similaire ne s’exécuterait pas sans un opérateur instanceof. Le code suivant ne sera pas compilé :

double height = 67;

final byte convertToByte = height;

Analyse robuste du flux de données dans IntelliJ IDEA

IntelliJ IDEA fournit une prise en charge robuste pour les types primitifs dans les instructions switch et intègre également une analyse avancée du flux de données afin d’aider les développeurs à éviter les problèmes les plus courants. Comme le montre l’exemple suivant, l’analyse du flux de données dans IntelliJ IDEA permet de déterminer que la deuxième étiquette case, à savoir case int _, et le reste des étiquettes case ne sont pas atteignables, le code sortant de la méthode si la valeur de la variable weight est supérieure à 70. IntelliJ IDEA vous signale le code inaccessible et vous fournit des suggestions appropriées :

Records et composants des types de données primitifs

Supposons que vous définissiez un record Person de la façon suivante :

record Person(String name, double weight) {}

Jusqu’à présent, vous pouviez le décomposer en types de données exacts. Cependant, les types primitifs dans les correspondances de motifs permettent d’utiliser d’autres types de données compatibles, tels que int, long, etc. Voici un exemple :

Person person = new Person("Java", 672);

switch (person) {
    case Person(String name, byte weight) -> println("byte:" + weight);
    case Person(String name, int weight) -> println("int:"  + weight);
    case Person(String name, double weight) -> println("double:" + weight);
    case Person(String name, long weight) -> println("long:" + weight);
    default -> throw new IllegalStateException("Unexpected value: " + person);
}

Vous pouvez aussi l’utiliser avec l’opérateur instanceof, de la façon suivante :

 if (person instanceof Person(String name, byte weight)) {
     System.out.println("Instanceof : " + weight);
 }

Ce qui est prévu dans IntelliJ IDEA pour la prise en charge de cette fonctionnalité

Le renforcement de la prise en charge des types de données primitifs dans la correspondance de motifs est en cours et inclut la possibilité d’utiliser l’opérateur postfix .switch sur tous les types de données primitifs pour commencer à écrire une construction switch. Il sera également possible de convertir une instruction if-else existante en construction switch utilisant des types de données primitifs, ce qui facilitera considérablement l’adoption de cette nouvelle fonctionnalité.

Commentaires de documentation Markdown (fonctionnalité de production)

Jusqu’à maintenant, les commentaires de documentation Java étaient écrits avec des balises HTML et JavaDoc. Avec la nouvelle fonctionnalité Documentation comments, vous pourrez également utiliser Markdown pour écrire des commentaires JavaDoc. Avec Java 23, il s’agit d’une fonctionnalité de production. Vous vous demandez peut-être quelle est la raison de ce changement ? L’une des raisons est que le HTML, qui était un très bon choix au moment de l’introduction de Java à la fin des années 90, n’est plus très populaire chez les jeunes développeurs. L’écriture manuelle de HTML n’est pas simple. Markdown est plus simple à écrire et à lire, et peut être facilement converti en code HTML. De nombreux développeurs utilisent maintenant Markdown pour documenter leur code, écrire des contenus tels que des articles et générer des pages de sites web, entre autres. Nous allons voir comment vous pouvez utiliser Markdown pour écrire des commentaires Javadoc dans votre fichier de code source et comment IntelliJ IDEA peut vous y aider.

Un exemple

Les commentaires de documentation Markdown commencent par ///. Le choix des trois barres obliques inverses est intéressant. Jonathan Gibbons, responsable de cette fonctionnalité chez Oracle, indique que modifier la syntaxe des fonctionnalités du langage Java n’est pas une tâche facile. Les commentaires multilignes commencent par /* et se terminent par */, ce qui rend difficile d’insérer dans la documentation du code qui incluerait */. C’est pourquoi les commentaires de documentation Markdown commencent par ///. L’ancienne façon d’écrire des commentaires de documentation, avec des balises HTML et JavaDoc, est également prise en charge. Jonathan mentionne aussi qu’il n’est pas possible de convertir des balises JavaDoc en un équivalent en Markdown. Les développeurs peuvent donc utiliser une combinaison de commentaires Markdown et de balises JavaDoc pour bénéficier des avantages de chacune de ces approches. Voici un exemple d’utilisation de balises Markdown et Javadoc pour documenter une méthode :

///
/// **Getting started and having fun learning Java :)**
///
/// Prints a pattern of the letter 'P' using the specified character.
///
/// @param size the size of the pattern
/// @param charToPrint the character to use for the pattern
///
private void printP(int size, char charToPrint) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (j == 0 || (i == 0 || i == size / 2) && j < size - 1 || (j == size - 1 && i <= size / 2)) {
                System.out.print(charToPrint + " ");
            } else {
                System.out.print("  ");
            }
        }
        System.out.println();
    }
}

IntelliJ IDEA vous aide à passer d’une vue à l’autre dans l’éditeur et à vérifier comment les commentaires de documentation apparaîtraient pour leurs lecteurs potentiels.

Visualiser les commentaires de documentation Java dans IntelliJ IDEA

Jonathan Gibbons, responsable de la JEP « Markdown Documentation Comments » insiste sur la nécessité pour tous les développeurs de vérifier que les commentaires de documentation Java qu’ils ont ajoutés à leur base de code sont corrects. IntelliJ IDEA fournit un « mode Lecteur » 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çon dont est affichée la documentation en utilisant la fonctionnalité « Toggle Rendered View », comme dans le GIF suivant :

Écrire des commentaires de documentation Markdown dans IntelliJ IDEA

IntelliJ IDEA est capable de détecter l’utilisation de Markdown pour documenter une méthode. Lorsque vous commencez par /// et appuyez sur Entrée, il ajoute /// sur la ligne suivante, comme illustré dans le GIF suivant :

Devez-vous convertir vos commentaires de documentation existants pour utiliser Markdown ?

Voici un GIF montrant la documentation de la méthode hashCode écrite avec Markdown dans IntelliJ IDEA. En sélectionnant « Toggle Rendered View » vous pouvez facilement visualiser la documentation dans la vue Lecteur, ce qui facilite la lecture et la compréhension.

Dans l’idéal, je déconseille de convertir votre documentation existante pour utiliser Markdown, sauf si vos développeurs ou utilisateurs d’API rencontrent des problèmes de lisibilité majeurs lorsqu’ils consultent votre base de code (API, bibliothèques, framework) en utilisant des outils n’offrant pas de vue alternative, contrairement à IntelliJ IDEA.

Déclarations d’importation de module (fonctionnalité preview)

Cette fonctionnalité permet d’importer une bibliothèque 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és par le module java.base. Vous 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és par java.base.

Exemple

L’exemple de code suivant utilise les classes des paquets java.io et java.util. En incluant l’instruction « import java.base », vous n’avez pas besoin d’importer les paquets java.io et java.util individuellement, car ils sont exportés par le module java.base :

import module java.base;
public class ImportModuleHelloWorld {

    public static void main(String[] args) {

        try {
            InputStream inputStream = new BufferedInputStream(
                                            new FileInputStream(
                                                   new File("abc.txt")));
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }

        Map list = new HashMap();
    }
}

Cependant, si vous supprimez l’instruction d’importation de module de la partie supérieure, 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 :

Quels paquets sont exportés par le module java.base (ou d’autres modules) ?

La réponse à cette question est simple lorsqu’on utilise IntelliJ IDEA. Cliquez sur le nom du module dans l’éditeur ou utilisez le raccourci correspondant (Go to Declaration ou Usages) afin de pouvoir visualiser la définition de ce module et d’identifier tous les modules qu’il exporte. Vous pouvez voir cela dans le GIF suivant :

Classes déclarées implicites et méthodes d’instance Main (troisième preview)

Introduite en tant que fonctionnalité preview avec Java 21, cette fonctionnalité en est à sa troisième preview avec Java 23. Elle est là pour changer la façon dont les nouveaux développeurs commencent à apprendre Java. Elle simplifie les étapes initiales pour les étudiants qui comment à apprendre les bases du langage, telles que l’affectation des variables, les séquences, les conditions et l’itération. Ils n’ont ainsi plus à déclarer une classe explicite pour développer leur code, ni à écrire leur méthode main() avec la signature public static void main(String []). Avec cette fonctionnalité, les classes peuvent être déclarées de façon implicite et la méthode main() peut être créée avec un nombre de mots-clés moins important. Si vous découvrez cette fonctionnalité, je vous invite à consulter mon article ‘HelloWorld’ and ‘main()’ meet minimalistic pour en savoir plus. Dans cette section, je vais évoquer les ajouts faits à cette fonctionnalité en Java 23.

Utiliser des paquets exportés par le module java.base sans les importer explicitement

En incluant une seule déclaration d’importation, à savoir import module java.base, en haut de votre classe implicite, vous pouvez importer automatiquement les paquets exportés 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 :

Simplifier l’écriture du code pour interagir avec la console

Interaction avec la console : l’impression ou la consommation de messages est l’une des actions les plus fréquemment utilisées par les nouveaux développeurs Java. Cela a été encore simplifié avec cette fonctionnalité. Les classes que vous avez déclarées implicitement peuvent utiliser les méthodes println() et print() pour afficher des messages sur la console et la méthode readln() pour lire des messages sous forme de chaîne sans les importer explicitement dans votre classe. Toutes ces méthodes sont déclarées dans une nouvelle classe de niveau supérieur, java.io.IO, qui est importée implicitement par les classes implicites. La façon dont vous devez les importer explicitement dans une classe normale est illustrée dans le GIF suivant : Le GIF montre que vous n’avez pas besoin d’importations explicites lorsque vous utilisez les mêmes méthodes précédentes dans une classe implicite :

Corps de constructeur flexibles (deuxième preview)

Il s’agit de la deuxième preview d’une fonctionnalité du JDK 22, appelée auparavant « Statements before super() ». Au-delà de ce changement de nom, cette fonctionnalité a fait l’objet d’une modification importante. Il est désormais possible d’initialiser les champs avant d’appeler super() ou this(), ce qui s’avère utile lorsqu’une superclasse appelle une méthode depuis son constructeur et que vous voulez remplacer cette méthode dans une sous-classe et accéder à un champ depuis la sous-classe dans cette méthode. Auparavant, le champ subclass n’était pas initialisé lorsque la méthode était appelée depuis le constructeur superclass. Il est désormais possible d’initialiser le champ et d’éviter les surprises. Voici un exemple de code illustrant cette fonctionnalité :

abstract class Action {
    public Action() {
        System.out.println("performing " + getText());
    }
    public abstract String getText();
}

class DoubleAction extends Action {
    private final String text;
    private DoubleAction(String text) {
        this.text = text; // this did not compile before Java 23 with preview features enabled.
        super();
    }

    @Override public String getText() {
        return text + text;
    }
}

Si vous découvrez cette fonctionnalité, je vous invite à consulter l’article que je lui ai consacré, qui explique pourquoi et comment l’utiliser : https://blog.jetbrains.com/idea/2024/02/constructor-makeover-in-java-22/.

Fonctionnalités preview

Les fonctionnalités présentées dans cet article, « types primitifs dans les motifs, instanceof et switch », « déclarations d’importation de module », « classes déclarées implicitement et méthodes d’instance main » et « corps de constructeur flexibles », sont toutes des fonctionnalités preview en Java 23. Avec un nouveau cycle de publication de six mois, les nouvelles fonctionnalités du langage sont fournies en version preview. Elles peuvent être réintroduites ultérieurement 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 être ajoutées à Java en tant que fonctionnalité standard du langage. Les fonctionnalités preview du langage sont complètes, mais pas permanentes, ce qui signifie essentiellement qu’elles sont prêtes à être utilisées par des développeurs, même si certains détails peuvent évoluer au fil des nouvelles versions de Java sur la base des retours des développeurs. Contrairement à une API, les fonctionnalités de langage ne peuvent plus devenir obsolètes. Par conséquent, si vous avez des commentaires sur l’une des versions preview des fonctionnalités du langage, n’hésitez pas à les partager via la mailing list de JDK (inscription gratuite requise). En raison du mode de fonctionnement de ces fonctionnalités, IntelliJ IDEA ne prend en charge que les fonctionnalités preview de la version actuelle de JDK. Les fonctionnalités en mode preview du langage peuvent varier selon les versions de Java, jusqu’à ce qu’elles soient abandonnées ou ajoutées en tant que fonctionnalités standard. Le code utilisant une fonctionnalité preview d’une version plus ancienne de Java SE Platform risque de pas être compilé ou exécuté sur une version plus récente.

Résumé

Dans cet article de blog j’ai couvert cinq fonctionnalités Java 23 : types primitifs dans les motifs, instanceof et switch, commentaires de documentation Markdown, déclarations d’importation de module, classes déclarées implicites et méthodes d’instance main et corps de constructeur flexibles. Je vous invite à les essayer pour découvrir comment elles peuvent vous aider à améliorer vos applications. Bon développement !