Java Break and Continuer les déclarations

La déclaration continue est utilisée dans le corps d'un certain temps, faire et pour boucle. L'instruction Break est utilisée dans ces boucles, ainsi que dans l'instruction Switch. L'itération peut être considérée comme l'exécution du corps d'une boucle, encore et encore. La déclaration de pause arrête l'itération. L'instruction CONSTANT saute une exécution (reste des déclarations ci-dessous) du corps. Cet article explique l'emploi des déclarations de poursuite et de rupture en Java. L'énoncé de composé de boucle while sera utilisé. Pour l'instruction BREAK, l'instruction Composé Switch sera également utilisée.

Une boucle

Ce qui suit tandis que la boucle imprime les numéros de 1 à 5.

int i = 0;
alors que je < 5)
++je;
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1 2 3 4 5

La première déclaration fait indirectement partie de la boucle. C'est un état de départ. La dernière déclaration ne fait pas partie de la boucle while. La condition de ce qui est «tandis que (je (je < 5)”.

Contenu de l'article

• La déclaration continue
• La déclaration de pause
• L'énoncé du composé de commutation et la rupture
• Conclusion

La déclaration continue
Continuer la déclaration en une seule boucle

Dans ce qui suit, la boucle, l'exécution (reste des instructions ci-dessous, continue) du corps, est sautée, lorsque je suis égal à 2:

int i = 0;
alors que je < 5)
++je;
si (i == 2)
continuer;
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1 3 4 5

La ou les déclarations en dessous de la condition, de i == 2, n'ont pas exécuté.

Continuer la déclaration dans une boucle imbriquée

La déclaration continue dans une boucle imbriquée n'affecte que la boucle imbriquée. Il n'envoie pas de contrôle à la boucle extérieure. Le code suivant illustre ceci:

char i = '@';
alors que je < 'E')
++je;
int j = 0;
tandis que (J < 5)
++J;
si (j == 2)
continuer;
Système.dehors.imprimer (j); Système.dehors.imprimer(");

Système.dehors.println ();
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1 3 4 5
A 1 3 4 5
B 1 3 4 5
C 1 3 4 5
D 1 3 4 5
E

Continuer la déclaration avec l'identifiant d'étiquette, dans une boucle

La commande continue peut avoir un argument, qui est l'identifiant d'une étiquette. En Java, l'étiquette permet la recommandation de la boucle. L'effet n'est pas perceptible pour une seule boucle. Le segment de code suivant l'illustre:

int i = 0;
LBL:
alors que je < 5)
++je;
si (i == 2)
continuer LBL;
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1 3 4 5

Continuer la déclaration avec l'étiquette dans une boucle imbriquée

Si l'étiquette cible la boucle extérieure, qui a la boucle intérieure, alors il y aura un effet. Le code suivant illustre ceci:

char i = '@';
LBL:
alors que je < 'E')
++je;
int j = 0;
tandis que (J < 5)
++J;
si (j == 2)
continuer LBL;
Système.dehors.imprimer (j); Système.dehors.imprimer(");

Système.dehors.println ();
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1 1 1 1 1

La déclaration de pause
casser la déclaration en une seule boucle

Dans la boucle suivante, le reste des instructions en dessous de l'instruction Break et le reste des itérations, arrête, quand je suis égal à 2:

int i = 0;
alors que je < 5)
++je;
si (i == 2)
casser;
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1

Déclaration de rupture dans une boucle imbriquée

La déclaration de rupture dans une boucle imbriquée affecte à la fois la boucle imbriquée et la boucle extérieure. Il envoie le contrôle à la boucle extérieure. Le code suivant illustre ceci:

char i = '@';
alors que je < 'E')
++je;
int j = 0;
tandis que (J < 5)
++J;
si (j == 2)
casser;
Système.dehors.imprimer (j); Système.dehors.imprimer(");

Système.dehors.println ();
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1
A 1
B 1
C 1
D 1
E

Déclaration de rupture avec l'identifiant d'étiquette, dans une boucle

La commande Break peut avoir un argument, qui est l'identifiant d'une étiquette. En Java, l'étiquette permet la recommandation de la boucle. L'effet n'est pas perceptible pour une seule boucle. Le segment de code suivant l'illustre:

int i = 0;
LBL:
alors que je < 5)
++je;
si (i == 2)
Break lbl;
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1

Déclaration de rupture avec étiquette dans une boucle imbriquée

Considérez le code suivant:

char i = '@';
LBL:
alors que je < 'E')
++je;
int j = 0;
tandis que (j < 5)
++J;
si (j == 2)
Break lbl;
Système.dehors.imprimer (j); Système.dehors.imprimer(");

Système.dehors.println ();
Système.dehors.imprimer (i); Système.dehors.imprimer(");

Système.dehors.println ();

La sortie est:

1

L'énoncé du composé de commutation et la rupture

L'instruction du composé de commutation transfère le contrôle à l'une des instructions composées plus courtes, en fonction de la valeur d'une expression, qui est l'argument de commutateur. Le type d'expression doit être char, octet, court, int, caractère, octet, court, entier, chaîne ou un type d'énumération. Les déclarations de composés plus courtes sont commencées par les étiquettes de cas. Une déclaration composée plus courte est un bloc de cas. En Java, après l'identification du bloc de cas, pour empêcher l'exécution de continuer aux blocs de cas en dessous, chaque bloc de cas doit se terminer par une «pause»;. Le code suivant illustre ceci:

int k = 2;
commutateur (k)
Cas 1: système.dehors.print ("un");
Système.dehors.print ("un");
Système.dehors.print ("un");
casser;
Cas 2: Système.dehors.print ("deux");
Système.dehors.print ("deux");
Système.dehors.print ("deux");
casser;
Cas 3: Système.dehors.print ("trois");
Système.dehors.print ("trois");
Système.dehors.print ("trois");
casser;

La sortie est:

twotwotwo

Conclusion

La déclaration de pause arrête l'itération. L'instruction CONSTANT saute une exécution (reste des déclarations ci-dessous) du corps. Si le programmeur ne veut pas que l'exécution d'une instruction Switch se poursuive en dessous d'un bloc de cas particulier, une instruction BRISE doit mettre fin à ce bloc de cas.

D'autres aspects à prendre en considération avec les déclarations Continuation et de rupture sont les suivants: Continuer la déclaration dans une boucle; Continuer la déclaration dans une boucle imbriquée; Continuer la déclaration avec l'identifiant d'étiquette, dans une boucle; Continuer la déclaration avec l'étiquette dans une boucle imbriquée; Déclaration de rupture dans une boucle; Déclaration de rupture dans une boucle imbriquée; Énoncé de rupture avec l'identifiant d'étiquette, dans une boucle; Déclaration de rupture avec étiquette dans une boucle imbriquée; et la déclaration de composé de commutation avec des pauses.