Cas multiples/répétitifs dans une instruction de commutateur Java

Question

Je voudrais savoir comment Java gère plusieurs instances identiques du même cas. Je pense que ce qui suit est logique, sur le plan conceptuel:

switch (someIntegerValue) 
{ 
    case 1: 
    case 2: 
     DoSomethingForBothCases(); 
     break; 
    case 3: 
     DoSomethingUnrelated(); 
     break; 
    case 1: 
     DoSomethingForCase1ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
    case 2: 
     DoSomethingForCase2ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
} 

Essentiellement, je voudrais avoir un morceau de code exécuté pour les deux cas, 1 ou 2 (en utilisant fall-through), mais plus tard, ont un morceau de code exécuté uniquement pour le cas 2.

Est-ce que ce qui suit est plutôt nécessaire?

switch (someIntegerValue) 
{ 
    case 1: 
     DoSomethingForBothCases(); 
     DoSomethingForCase1ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
    case 2: 
     DoSomethingForBothCases(); 
     DoSomethingForCase2ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
    case 3: 
     DoSomethingUnrelated(); 
     break; 
} 

Mon code actuel est plus complexe, mais utiliserait le même principe (à savoir quelque chose comme "cas 1: Nope, bien ... cas 2: yep exécuter ce code !; cas 3: Nope, cas 1 fois:? encore Nope !; cas 2 fois: yep exécuter ce code, pas plus de cas: Tous les Done ")

Answer 1

Vous ne pouvez pas répéter des cas dans une instruction Java switch, il s'agit d'une erreur de compilation. Vous devrez faire ce que vous avez suggéré, ce qui ressemble en fait à un bon affacturage.

Answer 2

ya un problème avec deux déclarations de commutation ?

switch (someIntegerValue) { 
    case 1: 
    case 2: 
     DoSomethingForBothCases(); 
     break; 
    case 3: 
     DoSomethingUnrelated(); 
     break; 
} 

switch (someIntegerValue) { 
    case 1: 
     DoSomethingForCase1ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
    case 2: 
     DoSomethingForCase2ThatReliesUponExecutionOfTheEarlierFunctionCall(); 
     break; 
} 

C'est ce que je ferais.

Answer 3

Vous ne serez pas en mesure de le faire. Vous ne pouvez pas avoir des cas en double, le compilateur jettera un liss hissy fit. Je comprends votre logique en ce sens que vous voudriez vérifier chaque cas et ensuite continuer et vérifier d'autres cas, mais la déclaration de rupture vous sortirait du casse-tête de toute façon. Ce que je recommanderais, c'est que vous envisagiez d'utiliser une boucle (c'est-à-dire pour, tout) si vous voulez vérifier différentes choses en continu. Couplage si des instructions avec une boucle vous aidera à exécuter des bits de code avant les autres.

Ou si vous aimez vraiment les instructions switch, vous pouvez créer plusieurs commutateurs afin que certaines choses arrivent avant les autres.

Answer 4

Comment ça? NOTE: Je ne sais pas beaucoup de Java, que Swift 2

var someIntegerValue = 1 

func someSwitch(){ 

switch (someIntegerValue) { 
    case 1: 
    break; 
    case 2: 
     DoSomethingForBothCases(); 
    break; 
    case 3: 
    DoSomethingUnrelated(); 
    break; 
    } 
} 

où vous avez un deux actions bouton,

une action bouton PROCHAINE

someIntegerValue +=1 // changes someIntegerValue to next case 
someIntegerValue() //loads switch 

une action bouton 2 Retour

someIntegerValue -=1 // changes someIntegerValue to next case 
someIntegerValue() //loads switch