Pourquoi est-ce que le code suivant: donne l'erreur: p> Continuer en dehors de la boucle p>
blockQuote> p>
7 Réponses :
ur code doit être, P> Continuer code> Interrupteur interne ?? !!! Seuls pause code> peut être conservé à l'intérieur du commutateur.! class swi22
{
public static void main(String[] args)
{
int a=98;
switch(a)
{
default:{ System.out.println("default");break;}
case 'b':{ System.out.println(a); break;}
case 'a':{ System.out.println(a);}
}
System.out.println("Switch Completed");
}
}
ne devriez-vous pas utiliser break code> au lieu de Continuer code>? P>
Vous utilisez continuer code> où vous devriez utiliser break code> p>
parce que vous avez un Il n'y a pas non plus besoin de mettre tous les cas de blocage des accolades (sauf si Vous voulez des variables scopées localement en eux). P> Alors quelque chose comme ça serait plus standard: p> Il y a aussi une école de pensée que dit la condition continuer code> en dehors d'une boucle. Continuer CODE> est de sauter au début d'une boucle, mais vous n'avez aucune boucle dans ce code. Ce que vous voulez de sortir d'un Switch code> Bloc de caisse est le mot-clé break code> (voir ci-dessous). par défaut code> doit toujours être à la fin. Ceci est pas em> une exigence, juste une convention assez largement utilisée. P> p>
Le Continuer code> -Statement peut être utilisé dans des boucles et non dans le commutateur. Ce que vous voulez probablement, c'est un break code>. P>
Utilisez Continuer: P> Continuer code> se déplace simplement directement sur la prochaine itération de la boucle. pause code> est utilisé pour sortir des boucles et des commutateurs. P> pause; code> au lieu de Continuer; code> p> switch(a)
{
default:{ System.out.println("default"); break;}
case 'b':{ System.out.println(a); break;}
case 'a':{ System.out.println(a);}
}
Falling à travers est le comportement standard d'une instruction de commutation. Par conséquent, en utilisant Continuer dans une instruction de commutation n'a pas de sens. La déclaration de poursuite n'est utilisée que pour / tandis que / faire des boucles [p> sur ma compréhension de vos intentions, vous voulez probablement écrire: p> i suggérerait également que vous placiez la condition par défaut à la fin. P> EDIT:
Il n'est pas tout à fait vrai que des déclarations de poursuite ne peuvent pas être utilisées à l'intérieur des relevés de commutation. A (idéalement étiqueté) Continuer Strong> est entièrement valide. Par exemple: p> Ceci produira la sortie suivante:
0
2
4
6
8 p> p>
Une continuité non étiquetée avancerait à la prochaine itération de la boucle et ne passerait pas à la prochaine affaire?
Sans l'étiquette, il fera le saut à boucle de la même manière.
Syntaxiquement, je suis trop d'accord mais quelle est la logique derrière cela pourquoi ne peut pas utiliser continuer où l'on peut utiliser une pause?
@Abson: parce que
continuer code> etbreak code> ont des objectifs différents, et tandis quebreak code> est pertinent pour les deuxcommutateur code> et à boucles ,continuer code> n'est pas - il n'y a pas de "haut" pour revenir à.Désolé, je suis arrivé, il ne s'agit que d'une déclaration conditionnelle et non d'une construction en boucle, c'est-à-dire?
@Abson: C'est vrai,
Switch code> n'est pas une boucle, c'est une recherche indexée (essentiellement optimisée si / eus / eus / eus / eus / eus / else / d'autre sans conditions en double autorisées).@TJCrowder Désolé pour ce commentaire tardif mais je veux signaler 1 chose: vous avez dit qu'il s'agissait d'un
optimisé si / else / else / indicatif>, mais ce n'est que si vous utilisez. code> à la fin de chaque cas code>, quelle est l'utilisation normale d'un commutateur code> code>. Si vous n'utilisez pas la casse, c'est comme:si quelque chose code> /si quelque chose || un autre code> /si quelque chose || Outils || Quelqueël CODE> / ... autant que j'ai compris que l'OP voulait qu'il utilise comme unsi / si / si / si / si / si code>, mais ce n'est pas possible avec un commutateur droit?@Springrbua: à droite, seulement si vous utilisez
break code>. Si vous ne le faites pas, c'est fondamentalement un goto, car vous allez à l'affaire correspondante, mais lorsque vous atteignez la fin de cette affaire, vous continuez avec la logique pour le prochain, même si cette affaire ne correspond pas, etc. jusqu'à ce que vous tombiez au bas du commutateur code> code>.