changer d'expression

La répétition est la mère de l'apprentissage. Bien que nous ayons déjà parlé du mot-clé switch de Java plus tôt, nous allons aujourd'hui revoir les bases et approfondir de nouvelles informations.

Java a deux types de constructions switch : l'instruction switch et l'expression switch. L'expression switch est devenue officielle dans Java 14, ayant existé dans deux variantes non officielles de "prévisualisation" dans les versions 12 et 13.

Mais commençons par le début. Rappelons à quoi ressemblait un bon vieux switch avant la version 12 :

public String getProductTypeByName(String product) {
    String productType = "";

    switch (product) {
        case "Apple":
            productType = "Fruit";
            break;

        case "Peach":
            productType = "Fruit";
            break;

        case "Raspberry":
            productType = "Berry";
            break;

        case "Cherry":
            productType = "Berry";
            break;

        case "Tomato":
            productType = "Vegetable";
            break;

        default:
            productType = "other";
            break;
    }
        
    return productType;
}

Une instruction switch est un ensemble de constructions qui seront exécutées les unes après les autres. Il ne vous permet pas de renvoyer une valeur. Le principal problème avec l'utilisation d'une instruction switch est que vous pouvez ajouter un nombre infini d' expressions de cas , et cette capacité est souvent abusée par les programmeurs.

Java 12 a vu l'ajout d'une fonctionnalité expérimentale : une nouvelle version de switch - pas une instruction switch, mais une expression switch - qui peut produire une valeur, utiliser la programmation fonctionnelle en interne et fusionner des instructions case qui ont une valeur commune, rendant ainsi le construire compact.

Dans Java 12, vous pouvez réécrire la méthode getProductTypeByName() comme suit :

public String getProductTypeByName(String product) {
    return switch (product) {
        case "Apple", "Peach" -> "Fruit";
        case "Raspberry", "Cherry" -> "Berry";
        case "Tomato" -> "Vegetable";
        default -> "other";

    };
}

Maintenant, le code semble plus propre. La syntaxe des flèches de la programmation fonctionnelle nous permet de renvoyer des valeurs sans le mot-clé break , et en général, le résultat de l'exécution du commutateur peut désormais être enregistré dans une variable ou renvoyé via le mot-clé return .

Si nous devons non seulement retourner un résultat, mais aussi avoir plusieurs lignes de code, alors notre commutateur ressemblera à ceci :

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            break "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            break "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            break "Vegetable";
        }
        default -> {
            break "other";
        }

    };
     return result;
}

Dans Java 13, l'expression switch était encore une fonctionnalité expérimentale. Pour le rendre disponible, tout comme dans Java 12, vous devez utiliser la commande --enable-preview lors de la compilation et de l'exécution. La principale, et essentiellement la seule, "innovation" du commutateur dans Java 13 est le mot-clé yield , qui a remplacé break .

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            yield "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            yield "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            yield "Vegetables";
        }
        default -> {
            System.out.println("Other");
            yield "other";
        }

    };
    return result;
}

La principale différence entre yield et break est que break renvoie le contrôle d'exécution à partir d'une instruction case , mais yield renvoie le résultat de l'ensemble switch , agissant comme une instruction de retour interne.

Dans Java 14, l' opérateur instanceof a changé et peut maintenant être utilisé comme ceci :

if (o instanceof String s) {
s.toLowerCase();
}

Au lieu de l'ancienne méthode un peu laide où vous deviez non seulement vérifier la variable en utilisant instanceof , mais aussi la convertir en un type spécifique.

if(s instanceof String) {
((String) s).toLowerCase();
}

Ces modifications font partie du projet Amber, qui vise à ajouter la prise en charge de la correspondance de modèles à Java.

Grâce au changement de l' opérateur instanceof dans la version 14 et à une extension dans la version 16, le pattern matching est finalement arrivé à la version 17. Certes, il n'existe qu'en avant-première pour l'instant. Vous pouvez l'essayer avec --enable-preview :

public String getObjectType(Object object) {
    return switch (object) {
        case Integer i -> "Integer";
        case Long l -> "Long";
        case String s -> "String";
        default -> object.toString();
    };
}

En général, chaque nouvelle version apporte de plus en plus de fonctionnalités intéressantes dans le langage, ce qui rend le développement Java encore plus cool.