Utilisation de deux valeurs pour une instruction switch case
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 à l'intérieur des cas text1 et 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 l'opérateur || ne fonctionnera pas dans l'instruction case mais y a-t-il quelque chose de similaire que je peux utiliser.
9 answers
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 dans 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);
}
}
Ceci est la sortie du code:
Number of Days = 29
FALLTHROUGH:
Un autre point d'intérêt est l'énoncé break. Chaque déclaration de pause termine l'instruction switch englobante. Le flux de contrôle continue avec la première instruction suivant le bloc de commutation. Les déclarations de rupture sont nécessaires parce que sans eux, les instructions dans les blocs de commutation
fall through: Toutes les instructions après l'étiquette de casse correspondante sont exécutées dans séquence, quelle que soit l'expression des étiquettes de casse 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);
}
}
}
}
Ceci est la sortie 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 le commutateur l'expression de la déclaration. Le code suivant exemple, , affiche le numéro du mois en fonction de la valeur de la Chaîne mois nommé:
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.
, Vous pouvez faire comme:
case text1:
case text4: {
//blah
break;
}
Les valeurs case ne sont que des points "goto" sans code qui peuvent partager le même point d'entrée:
case text1:
case text4:
//blah
break;
Notez que les accolades sont redondantes.
Juste faire
case text1: case text4:
do stuff;
break;
Les fallthrough réponses des autres sont bonnes.
Cependant, une autre approche consisterait à extraire les méthodes du contenu de vos instructions de cas, puis à appeler simplement la méthode appropriée de chaque cas.
Dans l'exemple ci-dessous, le cas 'text1' et le cas '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 instructions de cas plus maintenable et légèrement plus lisible, surtout lorsque les méthodes que vous appelez ont de bons noms descriptifs.
Les crochets ne sont pas nécessaires. Juste faire
case text1:
case text4:
doSomethingHere();
break;
case text2:
doSomethingElse()
break;
Si quelqu'un est curieux, cela s'appelle un cas fallthrough. La capacité de le faire est la raison pour laquelle break; est nécessaire pour mettre fin aux instructions de cas. Pour plus d'informations, voir l'article de wikipédia http://en.wikipedia.org/wiki/Switch_statement.
Tomber à travers l'approche est la meilleure que je ressens.
case text1:
case text4: {
//Yada yada
break;
}
Les valeurs de casse ne sont que des points "goto" sans code qui peuvent partager le même point d'entrée:
Cas texte1:
cas texte4: {
// Faire quelque chose
pause;
}
Notez que les accolades sont redondantes.
Avec l'intégration de JEP 325: Switch Expressions (Preview) dans les versions d'accès anticipé JDK-12, on peut maintenant utiliser la nouvelle forme de l'étiquette switch comme: -
case text1, text4 -> {
//blah
}
Ou pour reformuler la démo l'une 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);
}
}