faire boucle à faire en java

Une boucle est une déclaration composée dont le corps peut être exécuté à plusieurs reprises. Le corps de la boucle a un certain nombre de déclarations. Une boucle a besoin d'un état initial ou d'une instruction initiale, à partir de laquelle la boucle exécutera la première fois avant de répéter. Répéter signifie que toutes les déclarations de la boucle sont réexécutées, dans l'ordre, encore et encore. Pour que la boucle se répète après la première passe ou toute passe, il doit y avoir une déclaration qui le fera répéter. Pour qu'une boucle cesse de répéter, il doit y avoir une condition qui fera que la boucle ne se répétera pas.

Syntaxe de boucle à faire

La syntaxe de la construction de boucle à faire est:

// Instruction initiale ici
faire
// déclarations
// Cause de la prochaine itération
while (condition);

Cette construction doit être lue comme suit: Compte tenu de l'instruction initiale, faites toutes les instructions de la boucle tandis que la condition le permet. La déclaration initiale se termine par un point-virgule. La déclaration à do-composound elle-même se termine également par un point-virgule. Notez que «While» voici un mot réservé.

Il y a trois boucles principales en Java: la boucle à faire, la boucle while et la boucle pour. Ce tutoriel explique la boucle à faire et la compare à la boucle while et à la boucle pour.

Contenu de l'article

• Boucle à faire
• En comparant avec while-boucle
• Comparaison avec For-Bop
• Conclusion

Boucle à faire

En utilisant la syntaxe ci-dessus, un exemple de boucle de bricolage est dans le programme suivant:

classe theclass
public static void main (String [] args)
int myInt = 0;
faire
Système.dehors.imprimer (myInt + "");
myInt ++;
While (myInt< 5);
Système.dehors.println ();

La sortie est:

0 1 2 3 4

La construction complète commence par «int myint = 0;» et se termine à «While (myint < 5);”. There are two simple statements in the braces. The first statement in the braces prints out the value of the integer, myInt. The second statement increments myInt, adding 1 to it. The condition is “while (myInt < 5)”. So, while myInt is less than 5, the compound statement is re-executed.

Cette boucle n'a qu'une seule déclaration simple: pour imprimer la valeur de MyInt. La deuxième déclaration simple est de provoquer la prochaine itération. Les supports bouclés peuvent avoir plus d'une déclaration simple principale. La boucle à faire suivante a deux déclarations simples principales. Le premier ajoute 2 à MyInt, et le second imprime le résultat de l'addition:

classe theclass
public static void main (String [] args)
int myInt = 0;
faire
myInt = myInt + 2;
Système.dehors.imprimer (myInt + "");
myInt ++;
While (myInt< 13);
Système.dehors.println ();

La sortie est:

2 5 8 11 14

Cette sortie a besoin d'explication. Tout d'abord, notez que la condition While a été changée en «While (myInt < 13)”.

Quand MyInt est 0, 2 y est ajouté, et MyInt devient 2. Deux sont imprimés. L'incrément ajoute 1 à MyInt, et il devient 3 au début de la prochaine passe. Dans la prochaine itération (pass), MyInt a 3. Deux y sont ajoutés, et il devient 5. L'incrément ajoute 1 à Myint, et il devient 6. Dans la prochaine itération, MyInt a 6. 2 y est ajouté, et il devient 8. L'incrément ajoute 1 à Myint, et il devient 9. Dans la prochaine itération, MyInt a 9. 2 y est ajouté, et il devient 11. L'incrément ajoute 1 à Myint, et il devient 12. Dans la prochaine itération, MyInt a 12 ans. 2 y est ajouté, et il devient 14. L'incrément ajoute 1 à MyInt, et il devient 15. Après chaque itération, la condition While est vérifiée. À ce stade, alors que la condition est vérifiée, le MyInt est de 15, supérieur à 13, après 14. La condition entraîne une fausse et la répétition du bloc, arrêtez.

En comparant avec while-boucle

La syntaxe de la boucle While est:

// Instruction initiale ici
while (condition)
// déclarations
// Cause de la prochaine itération

La principale différence entre la boucle à faire et la boucle while est que pour la boucle while, la condition est vérifiée avant que le bloc soit exécuté. Notez que la construction de boucle while ne se termine pas par un point-virgule.

Le programme suivant répète le premier programme ci-dessus, mais avec une boucle de temps:

classe theclass
public static void main (String [] args)
int myInt = 0;
Pendant que (myint< 5)
Système.dehors.imprimer (myInt + "");
myInt ++;

Système.dehors.println ();

La sortie est la même que pour le premier programme ci-dessus, c'est-à-dire:

0 1 2 3 4

Le programme suivant répète le deuxième programme ci-dessus, mais avec une boucle de temps:

classe theclass
public static void main (String [] args)
int myInt = 0;
Pendant que (myint< 13)
myInt = myInt + 2;
Système.dehors.imprimer (myInt + "");
myInt ++;

Système.dehors.println ();

La sortie est la même que pour le deuxième programme ci-dessus, c'est-à-dire:

2 5 8 11 14

Comparaison avec For-Bop

La syntaxe pour la boucle pour:

pour (l'état initial; tandis que la condition; incrément)
// déclarations

Bien que la forme la plus restrictive, la boucle est concise de la boucle de bricolage ou de boucle. La boucle for-jacent a des parenthèses et un bloc. La déclaration initiale a été supprimée de l'extérieur et au-dessus de la construction dans les parenthèses. La condition de ce qui est la deuxième déclaration des parenthèses. La cause pour l'itination (incrément) est la dernière (troisième) déclaration des parenthèses.

Notez que la construction en boucle ne se termine pas par un point-virgule. Le programme suivant répète le premier programme ci-dessus, mais avec une boucle pour:

classe theclass
public static void main (String [] args)
for (int myint = 0; myInt< 5; myInt++)
Système.dehors.imprimer (myInt + "");

Système.dehors.println ();

La sortie est la même que pour le premier programme ci-dessus, c'est-à-dire:

0 1 2 3 4

Il n'y a pas de point-virgule après la déclaration d'incrément (dernière déclaration) dans les parenthèses.

Le programme suivant répète le deuxième programme ci-dessus, mais avec une boucle:

classe theclass
public static void main (String [] args)
for (int myint = 0; myInt< 13; myInt++)
myInt = myInt + 2;
Système.dehors.imprimer (myInt + "");

Système.dehors.println ();

La sortie est la même que pour le deuxième programme ci-dessus, c'est-à-dire:

2 5 8 11 14

Conclusion

La boucle à faire à Java répète l'exécution de son bloc, tant qu'une condition est vraie. Avant le bloc, la boucle à faire a besoin d'une déclaration initiale (état). La boucle à faire a besoin d'une déclaration de cause pour l'itage (incrément), généralement vers la fin de son bloc. La principale différence entre la boucle à faire et la boucle while est qu'avec la boucle à faire, le bloc est toujours exécuté avant la vérification de la condition, tandis qu'avec la boucle while, la condition est toujours vérifiée avant que le bloc ne soit réalisé. Le do- while et la boucle while font essentiellement la même chose. La boucle est une construction concise pour la boucle à faire ou à boucle.