Considérations relatives à la migration de Java 11 vers Java 17

Java 17 a apporté quelques modifications à Java, mais a également amené de nombreux développeurs à reconsidérer leur désir de migrer vers d'autres langages JVM. Les changements les plus évidents vont dans le sens de la modernisation du code Java et de l'ajout de nouvelles constructions de langage pour le simplifier. Bien sûr, ce problème n'est pas sans modifications du cœur de Java qui rendent Java plus efficace.

1. Bloc de texte

La fonctionnalité de bloc de texte est enfin là en Java. Je suis sûr que c'est l'un des changements attendus depuis longtemps pour les programmeurs Java. Vous pouvez désormais oublier les longues lignes composées difficiles à lire. Les blocs de texte vous permettent d'écrire du texte multiligne de la manière la plus pratique. Dans un tel bloc, vous pouvez écrire le texte comme vous le souhaitez et toujours utiliser des séquences d'échappement pour un formatage plus précis.

Java11. Séquences d'échappement de chaîne :

public String poem = "                " +
            "Twinkle, Twinkle, Little Star\n" +
            "                \n" +
            "                Twinkle, twinkle, little star,\n" +
            "                How I wonder what you are!\n" +
            "                Up above the world so high,\n" +
            "                Like a diamond in the sky.\n" +
            "                \n" +
            "                Twinkle, twinkle, little star,\n" +
            "                How I wonder what you are!";

Java17. TextBlock :

public String poem = """
                Twinkle, Twinkle, Little Star
                
                Twinkle, twinkle, little star,
                How I wonder what you are!
                Up above the world so high,
                Like a diamond in the sky.
                
                Twinkle, twinkle, little star,
                How I wonder what you are!
            """;

2、Enregistrer

Une autre mise à jour qui a lentement rendu le langage Java plus utile était les enregistrements. Auparavant, pour créer une classe, nous devions décrire la classe, spécifier ses champs et ajouter les méthodes nécessaires telles que equals, hashcode, getters et setters. Tout cela est désormais inutile depuis l'avènement des records.

record vous permet de créer des classes sécurisées pour les données en spécifiant uniquement les champs obligatoires ; toutes les autres méthodes seront créées automatiquement. Cependant, il convient de rappeler que les enregistrements agissent comme des classes de données, créées pour stocker des données, et non pour effectuer diverses opérations. Les enregistrements sont thread-safe car tous les champs d'enregistrement sont finaux. Une dernière chose importante à savoir est que les méthodes générées utilisées pour obtenir les valeurs des champs ne contiendront pas de "get" comme dans les Java Beans classiques.

Java11. Classe de données :

public class DataClass {
    public DataClass (Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    private final Integer id;
    private final String name;

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object o) {
        ...
    }

    @Override
    public int hashCode() {
        ...
    }
}

Java17.Record

public record DataClass(Integer id, String name) {
}

La différence est claire : la création d'un enregistrement nécessite beaucoup moins de lignes de code tout en exécutant la même fonctionnalité.

3. Nouvelle expression de commutateur

Les listes de modifications incluent également des expressions de basculement. Ces modifications ont non seulement affecté la syntaxe des expressions Switch (ce qui la rend plus concise à écrire), mais également la fonctionnalité. Les expressions de commutation renvoient désormais le résultat de l'itération, ce qui facilite l'écriture du code et le rend plus concis. La nouvelle expression de commutateur n'a plus besoin d'ajouter une pause après chaque cas

Java11. switch expression :

public String getSeasonDescription(Season season) {
        String seasonDescription;
        switch (season) {
            case SPRING:
                seasonDescription = "Flowers are blooming!";
                break;
            case SUMMER:
                seasonDescription = "It's hot outside!";
                break;
            case AUTUMN:
                seasonDescription = "Leaves are falling!";
                break;
            case WINTER:
                seasonDescription = "Snow is coming!";
                break;
            default:
                throw new IllegalStateException("Invalid season: " + season);
        }
        return seasonDescription;
    }

Java 17. Expression de commutateur améliorée :

public String getSeasonDescription(Season season) {
        return switch (season) {
            case SPRING -> "Flowers are blooming!";
            case SUMMER -> "It's hot outside!";
            case AUTUMN -> "Leaves are falling!";
            case WINTER -> "Snow is coming!";
        };
    }

4. instance de correspondance de modèle

Une autre amélioration de conception a également affecté l'opérateur. Maintenant, plus sûr et plus concis. Avec ce changement, il n'est plus nécessaire de vérifier d'abord si un objet donné est une instance d'une classe, puis d'effectuer le cast ; cela peut maintenant être fait en une seule ligne. Comme mentionné, ce n'est pas seulement du sucre syntaxique, mais un opérateur plus optimisé.

Java 11. Instance classique de

public void findInstance(Object o) {
        if (o instanceof String) {
            String s = (String) o;
            System.out.printf("Object is a string %s", s);
        } else if (o instanceof Number) {
            Number n = (Number) o;
            System.out.printf("Object is a number %n", n);
        }
    }

Java 17. Instanceof mise à jour

public void findInstance(Object o) {
        if (o instanceof String s) {
            System.out.printf("Object is a string %s", s);
        } else if (o instanceof Number n) {
            System.out.printf("Object is a number %n", n);
        }
    }

5. Classes scellées

Java 17 prend également en considération la sécurité et fait un pas important dans cette direction. L'idée est de limiter l'héritage d'une classe ou d'une interface tout en la gardant publique. En conséquence, un nouveau type de classe, la classe scellée, a été ajouté à Java. La syntaxe d'une classe scellée vous permet de spécifier des descendants dont les fonctionnalités peuvent être utilisées. Les héritiers, à leur tour, peuvent autoriser ou refuser l'héritage, ou spécifier des classes qui peuvent être héritées le long de la chaîne. Cette fonctionnalité vous permet de créer des projets de manière plus flexible et d'ajuster facilement l'API de votre code.

Java 17. Classes scellées :

public sealed class SealedClass permits AnotherSealedClass, AnotherNonSealedClass, AnotherFinalClass {
}

Java 17. Héritiers non scellés :

public non-sealed class AnotherNonSealedClass extends SealedClass {
}

Java 17. Héritiers finaux :

public final class AnotherFinalClass extends SealedClass {
}

Java 17. Héritiers scellés :

public sealed class AnotherSealedClass extends SealedClass permits AnotherNonSealedClassTwo {
}

Javai 17. Héritier descellé niveau 2 :

public non-sealed class AnotherNonSealedClassTwo extends AnotherSealedClass {
}

6、NullPointerExceptions

Enfin, une mise à jour très utile de Java 17 est la NullPointerException améliorée ! Enfin, dans le journal de suivi de la pile, vous pouvez voir quel champ spécifique a provoqué l'exception NullPointerException. Cette fonctionnalité à elle seule devrait vous inciter à passer à Java 17. Vous n'avez plus besoin de fouiller dans votre code pendant des heures pour trouver des endroits sinistres où des exceptions se produisent ; désormais, Java fera tout le travail pour vous.

Java11.NAME：

public static void main(String... args) {
        String s = null;
        System.out.println(s.toLowerCase());
    }

Exception in thread "main" java.lang.NullPointerException
 at Main.main(Main.java:4)

Java17. NPE amélioré :

public static void main(String... args){
        String s = null;
        System.out.println(s.toLowerCase());
    }

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.toLowerCase()" because "s" is null
 at edu.javamodules/edu.javaversions.eleventoseventeen.NpeExample.main(NpeExample.java:7)

7. Autres nouveautés

Bien sûr, il ne s'agit pas d'une liste exhaustive des modifications apportées à Java 17, mais les innovations évoquées sont les plus notables. Comme toujours, les développeurs Java ont fait un excellent travail en améliorant la JVM pour la rendre plus efficace.

8. Résumé

Toutes les améliorations apportées à Java 17 envoient un message : il est temps de passer à cette version. La syntaxe des promesses de transition est plus propre et les performances ont été améliorées. Vos projets gagneront en sécurité, en flexibilité et en meilleurs messages d'erreur. Si vous avez déjà migré vers Java11, la migration vers Java17 se fera en douceur. L'avantage concurrentiel de Java brille ici, car la rétrocompatibilité vous permet de passer à Java 17 sans modifier le code et de profiter de toutes les nouvelles fonctionnalités. Java17 est une autre version LTS (Long Term Support) depuis Java11, qui garantit que vous recevez toutes les mises à jour de sécurité nécessaires pendant une période prolongée.

9. Java comme outil de développement de langage

Les outils de développement rapide JNPF sont un ensemble de plateformes d'outils technologiques numériques, qui peuvent réaliser une construction rapide, l'arrangement des données, l'écologie de connexion, les services intermédiaires, etc. basés sur des méthodes plus efficaces telles que le glisser-déposer graphique et la configuration paramétrée. Réalisez l'innovation d'application de scénario dans la transformation numérique avec peu ou pas de code. Il peut atténuer ou même résoudre la contradiction entre l'offre et la demande causée par l'énorme demande du marché et la productivité du développement traditionnel, et est le produit de la tendance à la réduction des coûts et à l'augmentation de l'efficacité dans le processus de transformation numérique.

JNPF utilise le dernier cadre de séparation avant-arrière grand public (SpringBoot + Mybatis-plus + Ant-Design + Vue3). Le générateur de code a une faible dépendance, une capacité d'extension flexible et peut réaliser de manière flexible un développement secondaire.

Afin de prendre en charge le développement d'applications avec des exigences techniques plus élevées, la plate-forme low-code au niveau de l'entreprise représentée par JNPF n'a presque aucune différence par rapport au développement logiciel traditionnel de la modélisation de base de données, de la construction d'API Web à la conception de pages. Pour le travail répétitif de "l'addition, fonction de suppression, de modification et de requête", les partenaires qui n'ont pas encore appris le low-code peuvent essayer de le comprendre.

Adresse de candidature : https://www.jnpfsoft.com/?csdn

Avec lui, les développeurs peuvent facilement démarrer pendant le processus de développement et tirer pleinement parti de l'expérience accumulée dans le mode de développement traditionnel. Par conséquent, les plates-formes low-code sont d'une grande aide pour les programmeurs.