Utilisation de deux valeurs pour une instruction de type switch case

Question

Dans mon code, le programme fait quelque chose en fonction du texte saisi par l'utilisateur. Mon code ressemble à ceci :

switch (name) {
        case text1: {
            //blah
            break;
        }
        case text2: {
            //blah
            break;
        }
        case text3: {
            //blah
            break;
        }
        case text4: {
            //blah
            break;
        }

Cependant, le code à l'intérieur des cas text1 y text4 est le même. Je me demandais donc s'il me serait possible d'implémenter quelque chose comme

case text1||text4: {
            //blah
            break;
        }

Je sais que le || ne fonctionnera pas dans la déclaration de cas, mais y a-t-il quelque chose de similaire que je puisse utiliser ?

Answer 1

Vous pouvez utiliser les deux CASE comme suit.

  case text1: 
  case text4:{
            //blah
            break;
        }

VOIR CET EXEMPLE : Cet exemple de code calcule le nombre de jours d'un mois donné :

class SwitchDemo {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                numDays = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                numDays = 30;
                break;
            case 2:
                if (((year % 4 == 0) && 
                     !(year % 100 == 0))
                     || (year % 400 == 0))
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = "
                           + numDays);
    }
}

Voici le résultat de ce code :

Number of Days = 29

FALLTHROUGH :

Un autre point intéressant est la déclaration de rupture. Chaque instruction break met fin à l'instruction switch qui l'entoure. Le flux de contrôle continue avec la première instruction suivant le bloc switch. Les instructions break sont nécessaires car, sans elles, les instructions dans les blocs switch fall through : Toutes les instructions après l'étiquette de cas correspondante sont exécutées en séquence, indépendamment de l'expression des étiquettes de cas suivantes, jusqu'à ce qu'une instruction break soit rencontrée.

EXEMPLE DE CODE :

public class SwitchFallThrough {

    public static void main(String[] args) {
        java.util.ArrayList<String> futureMonths =
            new java.util.ArrayList<String>();

        int month = 8;

        switch (month) {
            case 1:  futureMonths.add("January");
            case 2:  futureMonths.add("February");
            case 3:  futureMonths.add("March");
            case 4:  futureMonths.add("April");
            case 5:  futureMonths.add("May");
            case 6:  futureMonths.add("June");
            case 7:  futureMonths.add("July");
            case 8:  futureMonths.add("August");
            case 9:  futureMonths.add("September");
            case 10: futureMonths.add("October");
            case 11: futureMonths.add("November");
            case 12: futureMonths.add("December");
            default: break;
        }

        if (futureMonths.isEmpty()) {
            System.out.println("Invalid month number");
        } else {
            for (String monthName : futureMonths) {
               System.out.println(monthName);
            }
        }
    }
}

Voici le résultat de ce code :

August
September
October
November
December

Utilisation de chaînes de caractères dans les instructions de commutation

En Java SE 7 et plus, vous pouvez utiliser un objet String dans le commutateur dans l'expression de l'instruction switch. L'exemple de code suivant, , affiche le numéro du mois en fonction de la valeur de l'objet String nommée mois :

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default: 
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}

La sortie de ce code est 8.

FROM Java Docs

Answer 2

Vous pouvez procéder comme suit pour utiliser plusieurs cas pour une seule instruction de commutation :

case "firstCase":
case "secondCase": {
    // Run code here for both cases
}

Answer 3

Le site case sont simplement des points d'accès sans code qui peuvent partager le même point d'entrée :

case text1:
case text4: 
    //blah
    break;

Notez que les accolades sont redondantes.

Answer 4

Fais-le.

case text1: case text4: 
     do stuff;
     break;

Answer 5

Le site fallthrough Les réponses des autres sont bonnes.

Cependant, une autre approche consisterait à extraire des méthodes du contenu de vos déclarations de cas, puis à appeler la méthode appropriée dans chaque cas.

Dans l'exemple ci-dessous, les cas "text1" et "text4" se comportent de la même manière :

switch (name) {
        case text1: {
            method1();
            break;
        }
        case text2: {
            method2();
            break;
        }
        case text3: {
            method3();
            break;
        }
        case text4: {
            method1();
            break;
        }

Personnellement, je trouve ce style d'écriture des déclarations de cas plus facile à maintenir et légèrement plus lisible, surtout lorsque les méthodes que vous appelez ont des noms bien descriptifs.