Utilisation de deux valeurs pour une instruction case switch
Dans mon code, le programme fait quelque chose en fonction du texte saisi par l'utilisateur. Mon code ressemble à:
switch (name) {
case text1: {
//blah
break;
}
case text2: {
//blah
break;
}
case text3: {
//blah
break;
}
case text4: {
//blah
break;
}
Cependant, le code dans les cas text1 et text4 est le même. Je me demandais donc s’il serait possible pour moi d’implémenter quelque chose comme
case text1||text4: {
//blah
break;
}
Je sais que l'opérateur || ne fonctionnera pas dans l'instruction case mais existe-t-il quelque chose de similaire que je puisse utiliser?.
Vous pouvez utiliser les deux instructions CASE comme suit.
case text1:
case text4:{
//blah
break;
}
VOIR CET EXEMPLE: L'exemple de code calcule le nombre de jours d'un mois particulier:
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 du code:
Number of Days = 29
TOMBER DANS:
La déclaration de rupture est un autre point d’intérêt. Chaque instruction break termine l'instruction switch incluse. Le flux de contrôle continue avec la première instruction suivant le bloc de commutation. Les instructions break sont nécessaires car, sans elles, les instructions des blocs de commutateurs
fall through: toutes les instructions suivant le libellé de casse correspondant sont exécutées dans l'ordre, quelle que soit l'expression des libellés de casiers suivants, jusqu'à ce qu'une déclaration break soit rencontrée.
CODE D'EXEMPLE:
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 du code:
August
September
October
November
December
Utilisation de chaînes dans les instructions switch
Dans Java SE 7 et versions ultérieures, vous pouvez utiliser un objet String dans l'expression de l'instruction switch. L'exemple de code suivant, affiche le numéro du mois en fonction de la valeur de la chaîne nommée month:
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.
tu peux faire comme:
case text1:
case text4: {
//blah
break;
}
Les valeurs case sont simplement des points "goto" sans code pouvant partager le même point d'entrée:
case text1:
case text4:
//blah
break;
Notez que les accolades sont redondants.
Il suffit de faire
case text1: case text4:
do stuff;
break;
Avec l’intégration de JEP 325: Expressions de commutateur (Preview) dans les versions d’accès anticipé JDK-12, il est désormais possible d’utiliser la nouvelle forme du libellé de commutateur en tant que: -
case text1, text4 -> {
//blah
}
ou pour reformuler la démo de ne des réponses , quelque chose comme: -
public class RephraseDemo {
public static void main(String[] args) {
int month = 9;
int year = 2018;
int numDays = 0;
switch (month) {
case 1, 3, 5, 7, 8, 10, 12 ->{
numDays = 31;
}
case 4, 6, 9, 11 ->{
numDays = 30;
}
case 2 ->{
if (((year % 4 == 0) &&
!(year % 100 == 0))
|| (year % 400 == 0))
numDays = 29;
else
numDays = 28;
}
default ->{
System.out.println("Invalid month.");
}
}
System.out.println("Number of Days = " + numDays);
}
}
Voici comment vous pouvez l'essayer - Compiler une fonction de prévisualisation JDK12 avec Maven
Les crochets sont inutiles. Il suffit de faire
case text1:
case text4:
doSomethingHere();
break;
case text2:
doSomethingElse()
break;
Si quelqu'un est curieux, cela s'appelle une faillite. La possibilité de faire cela est la raison pour laquelle break; est nécessaire pour terminer les instructions de casse. Pour plus d'informations, voir l'article de Wikipédia http://en.wikipedia.org/wiki/Switch_statement .
Les fallthrough 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 pour 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 que ce style d’écriture est plus facile à gérer et un peu plus lisible, en particulier lorsque les méthodes que vous appelez ont de bons noms descriptifs.
L’approche de chute est la meilleure que je ressens.
case text1:
case text4: {
//Yada yada
break;
}
Vous pouvez utiliser:
case text1: case text4:
do stuff;
break;
Les valeurs de casse sont juste des points "goto" sans code pouvant partager le même point d'entrée:
texte du cas1:
texte de l'affaire4: {
//Faire quelque chose
Pause;
}
Notez que les accolades sont redondants.