TOC

Instruction Java Switch

Déclaration Java Switch

1. Vue d'ensemble

Dans ce didacticiel, nous allons découvrir ce qu'est l'instructionswitch et comment l'utiliser.

L'instructionswitch nous permet de remplacer plusieurs constructionsif-else imbriquées et ainsi d'améliorer la lisibilité de notre code.

Switch a évolué au fil du temps - de nouveaux types pris en charge ont été ajoutés, en particulier dans Java 5 et 7. De plus, il continue d'évoluer - les expressionsswitch seront probablement introduites dans Java 12.

Ci-dessous, nous donnerons quelques exemples de code pour illustrer l'utilisation de l'instructionswitch, le rôle de l'instructionbreak, les exigences pour l'argumentswitch / les valeurscase et la comparaison deStrings dans l'instructiona switch.

Passons à l'exemple.

2. Exemple d'utilisation

Disons que nous avons les instructionsif-else imbriquées suivantes: 

public String exampleOfIF(String animal) {
    String result;
    if (animal.equals("DOG") || animal.equals("CAT")) {
        result = "domestic animal";
    } else if (animal.equals("TIGER")) {
        result = "wild animal";
    } else {
        result = "unknown animal";
    }
    return result;
}

Le code ci-dessus n'a pas l'air bien et serait difficile à maintenir et à raisonner. Pour améliorer la lisibilité, nous pourrions utiliser une instructionswitch ici: 

public String exampleOfSwitch(String animal) {
    String result;
    switch (animal) {
        case "DOG":
            result = "domestic animal";
            break;
        case "CAT":
            result = "domestic animal";
            break;
        case "TIGER":
            result = "wild animal";
            break;
        default:
            result = "unknown animal";
            break;
    }
    return result;
}

Comme indiqué ci-dessus, nous comparons l'argumentswitchanimal avec plusieurs valeurs decase. Si aucune des valeurscase n'est égale à l'argument, alors le bloc sous l'étiquettedefault est exécuté.

En termes simples, l'instructionbreak est utilisée pour quitter une instructionswitch.

3. L'instructionbreak

Bien que la plupart des instructionsswitch dans la vie réelle impliquent qu'un seul des blocscase doit être exécuté, l'instructionthe break est nécessaire pour quitter unswitch une fois le bloc terminé.

Si nous oublions d'écrire unbreak, les blocs en dessous seront exécutés.

Pour illustrer cela, omettons les instructionsbreak et ajoutons la sortie à la console pour chaque bloc: 

public String forgetBreakInSwitch(String animal) {
    switch (animal) {
    case "DOG":
        System.out.println("domestic animal");
    default:
        System.out.println("unknown animal");
    }
}

Exécutons ce codeforgetBreakInSwitch (“DOG”), et vérifions la sortie pour prouver que tous les blocs sont exécutés: 

domestic animal
unknown animal

Nous devons donc être prudents et ajouter des instructionsbreak à la fin de chaque bloc à moins qu'il ne soit nécessaire de passer au code sous l'étiquette suivante.

Le seul bloc où unbreak n'est pas nécessaire est le dernier, mais l'ajout d'unbreak au dernier bloc rend le code moins sujet aux erreurs.

Nous pouvons également profiter de ce comportement pouromit break when we want the same code executed for several case statements. Réécrivons l'exemple de la section précédente en regroupant les 2 premiers cas: 

public String exampleOfSwitch(String animal) {
    String result;
    switch (animal) {
        case "DOG":
        case "CAT":
            result = "domestic animal";
            break;
        case "TIGER":
            result = "wild animal";
            break;
        default:
            result = "unknown animal";
            break;
    }
    return result;
}

4. Argumentswitch et valeurscase

Voyons maintenant les types autorisés d'argumentswitch et de valeurscase, leurs exigences et le fonctionnement de l'instructionswitch avec les chaînes.

4.1. Types de données

Nous ne pouvons pas comparer tous les types d’objets et de primitives dans l’instructionswitch. A switch works only with four primitives and their wrappers, as well as with the enum type and the String class:

  • byte etByte

  • short etShort

  • int etInteger

  • char etCharacter

  • enum

  • Chaîne

String type est disponible dans l'instructionswitch à partir de Java 7.

Le typeenum a été introduit dans Java 5 et est depuis disponible dans l'instructionswitch.

Les classes wrapper sont également disponibles depuis Java 5.

Bien entendu, l'argumentswitch et les valeurscase doivent être du même type.

4.2. No null Values

We can’t pass the null value as an argument to a switch statement. Si nous le faisons, le programme lanceraNullPointerException, en utilisant notre premier sexampleswitch : 

@Test(expected=NullPointerException.class)
public void whenSwitchAgumentIsNull_thenNullPointerException() {
    String animal = null;
    Assert.assertEquals("domestic animal", s.exampleOfSwitch(animal));
}

Bien sûr, nous ne pouvons pas non plus passernull comme valeur à l’étiquettecase d’une instructionswitch. Si nous le faisons, le code ne sera pas compilé.

4.3. ValeursCase en tant que constantes à la compilation

Si nous essayons de remplacer la valeur de casDOG par la variabledog , le code ne se compilera pas tant que nous ne marquons pas la variabledog commefinal: 

final String dog="DOG";
String cat="CAT";

switch (animal) {
case dog: //compiles
    result = "domestic animal";
case cat: //does not compile
    result = "feline"
}

4.4. ComparaisonString

Si une instructionswitch utilisait l'opérateur d'égalité pour comparer des chaînes, nous ne pouvions pas comparer correctement un argumentString créé avec l'opérateurnew à une valeur de casString.

Heureusement, lesswitch operator uses the equals() method under the hood.

Voyons ceci: 

@Test
public void whenCompareStrings_thenByEqual() {
    String animal = new String("DOG");
    assertEquals("domestic animal", s.exampleOfSwitch(animal));
}

5. Nouvelle expressionswitch

Java 12 est disponible et avec lui l'aperçu d'une nouvelle fonctionnalité - une expressionswitch moins verbeuse.

Pour l'activer, nous devons passer–enable-preview au compilateur.

Nous allons jeter un coup d'oeil: 

var month = JUN;
var value = switch(month) {
  case JAN, JUN, JUL -> 3;
  case FEB, SEP, OCT, NOV, DEC -> 1;
  case MAR, MAY, APR, AUG -> 2;
};

System.out.println(value); // 3

Afin de tirer parti de la nouvelle syntaxe, nous n’utilisons plus le signe deux-points, mais l’opérateur connu de Lambda Expressions. Notez l'absence de mot-clébreak et que les cas de défaillance ne se produisent pas.

Mais il est toujours possible d'obtenir un contrôle précis sur ce qui se passe sur le côté droit de l'expression à l'aide de blocs de code. Dans un tel cas, nous devons manuellementbreak à partir de celui-ci et spécifier une valeur de retour: 

public static void switchLocalVariable() {
    var month = Month.AUG;
    int i = switch (month){
        case JAN,JUN, JUL -> 3;
        case FEB,SEP, OCT, NOV, DEC -> 1;
        case MAR,MAY, APR, AUG -> {
            int j = month.toString().length() * 4;
            break j;
        }
    };
    System.out.println(i); //12
}

6. Conclusion

Dans ce tutoriel, nous avons appris les subtilités de l'utilisation de l'instructionswitch en Java. Nous pouvons décider d'utiliser ou nonswitch  en fonction de la lisibilité et du type des valeurs comparées.

L'instruction switch est un bon candidat pour les cas où nous avons un nombre limité d'options dans un ensemble prédéfini (par exemple, les jours de la semaine). Sinon, nous devrons modifier le code chaque fois qu'une nouvelle valeur est ajoutée ou supprimée, ce qui peut ne pas être possible. Pour ces cas, nous devrions envisager d'autres approches telles quepolymorphism ou d'autres modèles de conception commeCommand.

Comme toujours, le code complet est disponibleover on GitHub.

Related