1. Structure circulaire
Une instruction LOOP peut exécuter à plusieurs reprises un certain morceau de code lorsque la condition de boucle est remplie. Ce code répété est appelé une instruction corporelle de boucle. Lorsque ce corps de boucle est exécuté à plusieurs reprises, la condition de jugement de boucle doit être modifiée à False au moment approprié pour mettre fin à la boucle, sinon la boucle continuera de s'exécuter, formant une boucle morte.
Composition des instructions de boucle:
Instruction d'initialisation: une ou plusieurs instructions, ces instructions effectuent certaines opérations d'initialisation.
Énoncé conditionnel de décision: il s'agit d'une expression booléenne, qui peut déterminer s'il faut exécuter le corps de la boucle.
Déclaration du corps en boucle: cette partie est une déclaration de boucle, c'est ce que nous devons faire à plusieurs reprises.
Énoncé de la condition de contrôle: Cette pièce est exécutée avant que la condition de jugement du cycle suivant ne soit exécutée après la fin du corps du cycle. En contrôlant les variables dans la condition de boucle, la boucle se termine au moment approprié.
EG: Quand "Helloworld" est sorti 10 fois sur la console,
Instruction d'initialisation: définissez l'initialisation comme la première fois.
Déclaration conditionnelle du jugement: le nombre de fois ne peut pas dépasser 10 fois.
Énoncé du corps de boucle: Sortie de l'instruction "Helloworld".
Énoncé de la condition de contrôle: le nombre de fois passe à la prochaine fois.
2. Structure de boucle (pour l'énoncé de boucle)
Pour le format de l'instruction LOOP:
pour (déclaration d'initialisation; déclaration conditionnelle du jugement; déclaration conditionnelle du contrôle) {
Déclaration du corps en boucle;
}
Processus d'exécution:
A: Exécuter l'instruction d'initialisation
B: Exécutez la déclaration conditionnelle du jugement pour voir si le résultat est vrai ou faux: s'il est faux, la boucle se termine; Si c'est vrai, continuez à exécuter.
C: Exécuter la déclaration du corps de la boucle
D: Exécuter l'instruction de condition de contrôle
E: Revenez à B et continuez
Tableau de débit:
Notes:
(1) Le résultat de la déclaration conditionnelle du jugement est un type booléen
(2) Si l'instruction LOOP est une instruction unique, les accolades peuvent être omises; S'il s'agit de plusieurs instructions, les accolades ne peuvent pas être omises. Il est recommandé de ne pas l'omettre.
(3) De manière générale: s'il y a une attelle gauche, il n'y a pas de point-virgule, s'il y a un point-virgule, il n'y a pas de pointe gauche.
Exemple de code:
1. Trouvez la somme des nombres pair entre 1 et 100:
/ * Exigences: A: Trouvez la somme de 1-100. B: Trouvez la somme des nombres pair entre 1-100 * / classe FORTEST1 {public static void main (String [] args) {// Trouvez la somme de 1-100. int sum1 = 0; pour (int x = 1; x <= 100; x ++) {sum1 + = x; } System.out.println ("1-100 est:" + sum1); System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // Méthode 2 int sum3 = 0;2. Trouvez le factoriel de 5:
/ * Exigence: trouvez le factoriel de 5. Qu'est-ce que factoriel? N! = n * (n-1)! Règle N! = n * (n-1) * (n-2) * ... * 3 * 2 * 1 Ideologie de somme. Trouvez la pensée factorielle. * / class FORTEST2 {public static void main (String [] args) {// définir la variable de résultat finale int JC = 1; // Le x ici peut réellement démarrer directement à partir de 2 // pour (int x = 1; x <= 5; x ++) pour (int x = 2; x <= 5; x ++) {jc * = x; } System.out.println ("1-5 factoriel est:" + jc); }}3. Sortir tout "numéro de narcisse" dans la console:
/ * Exigences: Sortir tous les "numéros de narcisse" sur l'analyse de la console: nous ne savons pas quels sont les "numéros de narcisse", que me demandez-vous de faire? Les nombres dits de Narcissus se réfèrent à un nombre à trois chiffres, et la somme du cube de leurs chiffres est égale au nombre lui-même. Par exemple: 153 est une jonquille. 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 1 + 125 + 27 = 153 A: Le nombre à trois chiffres nous dit en fait la plage. B: Grâce à la boucle FOR, nous pouvons obtenir chaque numéro à triple chiffre, mais le problème est de savoir comment obtenir les données de ce numéro à triple chiffre, dix et centaines. Comment obtenir les données d'une données, dix et centaines? Supposons qu'il y ait des données: 153 GE: 153% 10 = 3 Shi: 153/10% 10 = 5 Bai: 153/10/10% 10 = 1 Qian: x / 10/10/10% 10 Wan: X / 10/10/10/10% 10 ... C: Let Ge * Ge * Ge + Shi * shi * shi + bai * bai * bai compare avec les données, et diffusé les données sur le consolence. * / class Fortest3 {public static void main (String [] args) {// Le triple chiffre nous dit en fait la plage. pour (int x = 100; x <1000; x ++) {int ge = x% 10; int shi = x / 10% 10; int bai = x / 10/10% 10; // Soit ge * ge * ge + shi * shi * shi + bai * bai * bai comparez avec les données if (x == (ge * ge * ge + shi * shi * shi + bai * bai)) {// si le même, émettez les données sur la console. System.out.println (x); }}}}3. Structure de boucle (tandis que la déclaration de boucle)
Alors que le format de l'instruction LOOP:
tandis que (déclaration conditionnelle du jugement) {
Déclaration du corps en boucle;
}
// Instruction d'initialisation du format étendu;
tandis que (déclaration conditionnelle du jugement) {
Déclaration du corps en boucle;
Énoncé de condition de contrôle;
}
Tableau de débit:
La différence entre une boucle pour une boucle:
Pour les instructions de boucle et bien que les instructions de boucle puissent être converties de manière équivalente, mais il y a encore de petites différences.
(1) Différences d'utilisation:
La variable contrôlée par l'instruction conditionnelle de contrôle ne peut pas être accessible après les extrémités de la boucle pour et peut continuer à être utilisée après les fins de boucle while. Si vous souhaitez continuer à l'utiliser, utilisez While, sinon il est recommandé de l'utiliser. La raison en est que la boucle FOR se termine et la variable disparaît de la mémoire, ce qui peut améliorer l'efficacité de l'utilisation de la mémoire.
(2) Différence de scène:
Car Loop convient au fonctionnement pour un jugement de portée tandis que la boucle convient au fonctionnement pour un nombre peu clair de jugements
Exemple de code:
La plus haute montagne de notre pays est le mont Everest: 8848m. J'ai maintenant un papier suffisamment grand avec une épaisseur de: 0,01 m. Puis-je demander, combien de fois je le plie pour m'assurer que l'épaisseur n'est pas inférieure à la hauteur du mont Everest?
/ * La plus haute montagne de notre pays est le mont Everest: 8848m. J'ai maintenant un papier suffisamment grand avec une épaisseur de: 0,01 m. Puis-je demander, combien de fois je me plie, je peux m'assurer que l'épaisseur n'est pas inférieure à la hauteur du mont Everest? Analyse: A: Définir une variable statistique, la valeur par défaut est 0 B: Le pic le plus élevé est le mont Everest: 8848m Il s'agit de l'épaisseur finale. J'ai maintenant un morceau de papier suffisamment grand, avec une épaisseur de: 0,01 m, c'est l'épaisseur initiale C: Combien de fois je me plie, je peux m'assurer que l'épaisseur n'est pas inférieure à la hauteur du mont Everest? Quels changements se produiront si je le plie une fois? C'est-à-dire que l'épaisseur est deux fois plus épaisse qu'auparavant. D: Tant que l'épaisseur de chaque changement ne dépasse pas la hauteur du mont Everest, il sera plié, variable statistique ++ E: Variables statistiques de sortie. * / class whileTest01 {public static void main (String [] args) {// définir une variable statistique, la valeur par défaut est 0 int count = 0; // Le pic le plus élevé est le mont Everest: 8848m C'est l'épaisseur finale // J'ai maintenant un papier suffisamment grand, avec une épaisseur de: 0,01 m, c'est l'épaisseur initiale // Pour une simplicité, j'ai transformé 0,01 en 1, et la même manière que 8848 est devenu 884800 int End = 884800; int start = 1; tandis que (start <end) {// tant que l'épaisseur de chaque changement ne dépasse pas la hauteur du mont Everest, le pliez et la variable statistique ++ Count ++; // Quels changements se produiront s'il est plié une fois? C'est que l'épaisseur est deux fois la fois la précédente. démarrer * = 2; System.out.println ("Th" + Count + "L'épaisseur est" + start); } // Sortie des variables statistiques. System.out.println ("à être empilé" + Count + "Time"); }}4. Structure de boucle (DO… Instruction LOOP)
Format de base:
faire {
Déclaration du corps en boucle;
} while ((déclaration conditionnelle du jugement); [/ code]
Format étendu:
Instruction d'initialisation;
faire {
Déclaration du corps en boucle;
Énoncé de condition de contrôle;
} while ((déclaration conditionnelle du jugement); [/ code]
Tableau de débit:
5. Différences et précautions pour la structure cyclique:
Les trois instructions de boucle peuvent en fait remplir la même fonction, ce qui signifie qu'ils peuvent convertir de manière équivalente, mais il y a encore de petites différences:
Le DO… tandis que la boucle exécutera le corps de la boucle au moins une fois. Pour la boucle et bien que la boucle ne fera que l'exécution du corps de la boucle que lorsque la condition est vraie
1. Remarques:
Lorsque vous rédigez des programmes, vous devez donner la priorité à la boucle pour, puis considérer la boucle while, et enfin considérer le DO ... WHIT LOOP.
Le code suivant est une boucle morte:
tandis que (true) {}
pour(;;){}
2. Utilisation imbriquée des boucles: le corps de boucle de l'instruction LOOP lui-même est une déclaration de boucle
(1) Question 1: Veuillez produire un modèle étoile (*) avec 4 lignes et 5 colonnes:
Astuce: le nombre de lignes contrôlées par la boucle extérieure et le nombre de colonnes contrôlées par la boucle intérieure
/ * Exigences: veuillez produire la forme suivante * ** *** **** **** ** ***** Astuce: la boucle extérieure contrôle le nombre de lignes, la boucle intérieure contrôle le nombre de colonnes * / class pour une observation simple, nous voyons une forme de 5 ans et le nombre de colonnes est une forme changeante // Nous voyons une forme de 5 et le nombre de colonnes est une forme changeante // nous voyons une forme de 5 et le nombre de colonnes est une forme changeante // Nous voyons une forme de 5 et le nombre de colonnes est une forme changeante // nous et 5 colonnes pour (int x = 0; x <5; x ++) {pour (int y = 0; y <5; y ++) {System.out.print ("*"); } System.out.println (); } System.out.println ("-----------------------------------------------------); // Nous avons implémenté une forme de 5 lignes et 5 colonnes // mais ce n'est pas ce que nous voulons // Ce que nous voulons, c'est le changement de nombre de colonnes / colonnes. y = 0, y <= 1, y ++ // La troisième ligne: 3 colonnes y = 0, y <= 2, y ++ // la quatrième ligne: 4 colonnes y = 0, y <= 3, y ++ // la cinquième ligne: 5 colonnes y = 0, y <= 4, y ++ /+ // En regardant le changement de x dans la version finale de la version finale, il se produit comme suit (int x = 0; x <5; x ++) {pour (int y = 0; y <= x; y ++) {System.out.print ("*");} System.out.println ();(2) Question 2: Sortie du tableau de multiplication neuf-neuf sur la console:
/ * Exigences: Sortie du tableau de multiplication neuf-neuf dans la console. First we write the nine-nine multiplication table: 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 ... 1*9=9 2*9=18 3*9=27 ... Let's first see this nine-nine multiplication table as such: * ** ********* ********* ********* ********* ********* ********* Remarque: '/ x' x signifie tout, cette méthode est appelée caractères de transfert. '/ t' La position d'un caractère d'onglet (touche tabtab) '/ r' Entrée '/ n' Break * / class for Fortest02 {public static void main (String [] args) {for (int x = 0; x <9; x ++) {for (int y = 0; y <= x; y ++) {system.out.print ("*"); } System.out.println (); } System.out.println ("----------------------"); // Pour utiliser des données, nous commençons à partir de 1 pour (int x = 1; x <= 9; x ++) {pour (int y = 1; y <= x; y ++) {System.out.print (y + "*" + x + "=" + y * x + "/ t"); } System.out.println (); }}}Effet de course:
6. Énoncé de contrôle de saut:
Comme nous l'avons déjà dit auparavant, Goto in Java est un mot réservé et ne peut pas être utilisé pour le moment. Bien qu'il n'y ait pas de déclaration GOTO pour améliorer la sécurité du programme, elle apporte également beaucoup de désagréments. Par exemple, je veux terminer quand une certaine boucle sait à une certaine étape, et je ne peux pas le faire maintenant. Afin de compenser ce défaut, Java fournit une rupture, continuer et revenir pour contrôler les sauts et les interruptions des déclarations.
casser l'interruption
continuer
retour
1. Énoncé de contrôle de saut (pause):
Utilisez des scénarios pour la pause:
~ Dans l'instruction Switch pour sélectionner la structure
~ Dans l'instruction Loop (si un jugement est ajouté à la déclaration de boucle)
Remarque: il n'a pas de sens pour quitter le scénario d'utilisation
La fonction de la pause:
R: Sortez de la boucle unique
B: Sortez de la boucle multicouche
Pour réaliser cet effet, vous devez savoir quelque chose. Une déclaration avec étiquette. Les noms de balises doivent se conformer aux règles de dénomination de Java
Format:
Nom de la balise: déclaration
Exemple de code:
/ * Control Jump Instruction: Break: Interrupt Continuation: Continuer: Retour: Retour Break: Interrupt Signification Scénario: A: Instruction Switch B: Loop Instruction. (Si le jugement est ajouté à l'instruction LOOP) Remarque: Il n'a pas de sens de quitter les deux scènes ci-dessus. Comment l'utiliser? R: Sortez d'une boucle unique B: Sortez d'une boucle multicouche pour réaliser cet effet, vous devez savoir quelque chose. Une déclaration avec étiquette. Format: Nom de la balise: instruction * / class BreakDemo {public static void main (String [] args) {// offset extérieur commutateur ou boucle // break; // décalé une boucle unique pour (int x = 0; x <10; x ++) {if (x == 3) {Break; } System.out.println ("Helloworld"); } System.out.println ("Over"); System.out.println ("---------------"); // Offset a une boucle multi-couches wc: for (int x = 0; x <3; x ++) {nc: for (int y = 0; y <4; y ++) {if (y == 2) {// briser nc; casser wc; } System.out.print ("*"); } System.out.println (); }}}Dans la ligne 38, nous ajoutons une balise à la boucle extérieure appelée WC, puis sautons de cette balise en ligne 42.
Effet de course:
Remarque: Dans le développement réel, la fonction du saut en boucle multicouche est presque impossible à utiliser.
2. Énoncé de contrôle de saut (Continuer):
Utilisez des scénarios pour continuer:
Il est inutile de laisser le scénario d'utilisation dans une déclaration de boucle
La différence entre continuer et casser:
Break Sortez l'expression de la boucle unique continue de sortir d'une boucle et entre dans la prochaine exécution.
Les effets sont les suivants:
Questions d'entrevue:
pour (int x = 1; x <= 10; x ++) {if (x% 3 == 0) {// Remplissez le code ici} System.out.println ("Java Learning"); }Remplissez la ligne 4 du code ci-dessus pour satisfaire les conditions suivantes:
Je veux sortir 2 fois dans la console: "Java Learn" Break;
Je veux sortir 7 fois dans la console: "Java Learning" continue;
Je veux sortir 13 fois dans la console: "Java Learning" System.out.println ("Java Learning");
3. Énoncé de contrôle de saut (retour)
Le mot-clé de retour ne consiste pas à sauter du corps de la boucle. La fonction la plus couramment utilisée consiste à mettre fin à une méthode, c'est-à-dire à quitter une méthode et à sauter sur la méthode appelée dans la couche supérieure.
Pour le dire franchement: la fonction du retour n'est pas de mettre fin à la boucle, mais de mettre fin à la méthode.
Les effets sont les suivants:
Exercices d'instructions en boucle combinées à la pause:
Question d'entrevue: La mère de Xiaofang lui donne 2,5 yuans par jour, et elle le sauvera. Cependant, chaque fois que ce jour est le 5ème jour de l'épargne ou un multiple de 5, elle passera 6 yuans. Combien de jours Xiaofang peut-il le sauver à 100 yuans.
Implémentation du code:
/ * Exigences: la mère de Xiaofang lui donne 2,5 yuans par jour, et elle le sauvera. Cependant, chaque fois que ce jour est le 5ème jour de l'épargne ou un multiple de 5, elle passera 6 yuans. Combien de jours Xiaofang peut-il le sauver à 100 yuans. Analyse: A: La mère de Xiaofang lui donne 2,5 yuans par jour, double daymoney = 2,5; B: Elle sauvera Double Daysum = 0; C: Stocker int DayCount = 1 du premier jour; D: Combien de jours Xiaofang sauvera-t-il 100 yuans. Double résultat = 100; E: Si ce jour est le 5ème jour de l'épargne ou du multiple de 5, elle passera 6 yuans, indiquant qu'elle doit juger de la valeur de DayCount. Si le 5 est divisé, 6 yuans sera soustrait. Daysum - = 6; Cela implique également un problème, c'est-à-dire, s'il ne s'agit pas d'un multiple de 5 jours, l'argent doit être accumulé Daysum + = Daymoney; F: Parce que je ne sais pas combien de jours c'est, j'utilise une boucle morte. Une fois qu'il dépasse 100 yuans, je quitterai la boucle. * / class whiledemo {public static void main (String [] args) {// L'argent à stocker tous les jours est 2,5 yuan double daymoney = 2,5; // La valeur d'initialisation de l'enregistrement est 0 Double Daysum = 0; // Storage int DayCount = 1 du premier jour; // Le stockage final n'est pas inférieur à 100 et le résultat int = 100; // Parce que je ne sais pas combien de jours c'est, j'utilise une boucle morte, tandis que (true) {// accumule l'argent Daysum + = Daymoney; // Une fois qu'il dépasse 100 yuans, je sors de la boucle. if (dayum> = result) {System.out.println ("Dépenser un total de 100 yuans en stockage au total"); casser; } if (dayCount% 5 == 0) {// Passez 6 yuans dayum - = 6; System.out.println ("Things" + DayCount + "Dépenser un 6 yuans au total"); } // Le nombre de jours change DayCount ++; }}}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.