Contrôle du cycle
Il peut y avoir une situation où nous devons exécuter des blocs de code plusieurs fois, ce qui est généralement appelé boucle.
Java a un mécanisme très flexible en trois boucles. L'une des trois boucles suivantes peut être utilisée:
Depuis Java 5, une boucle améliorée est introduite. Ceci est principalement utilisé pour les tableaux.
pendant la boucle
Tandis que la boucle est une structure de contrôle qui peut répéter un nombre spécifique de tâches.
grammaire
La syntaxe d'une boucle de temps est:
while (boolean_expression) {// instructions}Lors de l'exécution, si le résultat de l'expression booléenne est vraie, les actions dans la boucle seront exécutées. Tant que le résultat de l'expression est vraie, l'exécution se poursuivra.
Ici, le point clé de la boucle while est que la boucle peut ne pas fonctionner éternellement. Lorsque l'expression est testée, le résultat est faux, le corps de la boucle sera ignoré et la première instruction après la boucle While sera exécutée.
Exemple
classe publique test {public static void main (String args []) {int x = 10; while (x <20) {System.out.print ("Valeur de x:" + x); x ++; System.out.print ("/ n"); }}}Cela produira les résultats suivants:
Valeur de x: 10value de x: 11value de x: 12value de x: 13value de x: 14value de x: 15value de x: 16value de x: 17value de x: 18value de x: 19
faire ... pendant la boucle
faire ... tandis que la boucle est similaire à une boucle while, sauf que un ... tandis que la boucle est garantie pour être exécutée au moins une fois.
grammaire
La syntaxe d'un DO ... tandis que la boucle est:
faire {// instructions} while (boolean_expression);Notez que l'expression booléenne apparaît à la fin de la boucle, donc l'instruction dans la boucle effectue le test booléen précédent.
Si l'expression booléenne est vraie, le flux de contrôle saute en arrière et l'instruction dans la boucle est à nouveau exécutée. Ce processus est répété jusqu'à ce que l'expression booléenne soit fausse.
Exemple
classe publique test {public static void main (String args []) {int x = 10; do {System.out.print ("Valeur de x:" + x); x ++; System.out.print ("/ n"); } while (x <20); }}Cela produira les résultats suivants:
Valeur de x: 10value de x: 11value de x: 12value de x: 13value de x: 14value de x: 15value de x: 16value de x: 17value de x: 18value de x: 19
pour boucle
La boucle FOR est une structure de contrôle de boucle qui peut rédiger efficacement une boucle d'un nombre spécifique de fois qui doit être exécutée.
Lorsque vous savez combien de fois une tâche doit être répétée, une boucle pour une boucle est bénéfique.
grammaire
La syntaxe de A pour la boucle est:
pour (initialisation; boolean_expression; mise à jour) {// instructions}Ce qui suit est le processus de contrôle d'une boucle pour
L'étape d'initialisation est effectuée en premier et une seule fois. Cette étape déclare et initialise toutes les variables de contrôle de boucle. Il n'est pas nécessaire de mettre une déclaration ici, juste un point-virgule doit apparaître.
Ensuite, l'expression booléenne évalue. Si c'est vrai, le corps de la boucle est exécuté. S'il est faux, le corps de la boucle ne sera pas exécuté et le contrôle de processus passera à la prochaine instruction passant par la boucle pour.
Après cela, lorsque le corps de la boucle est exécuté pour la boucle, le processus de contrôle passe à la sauvegarde de l'instruction de mise à jour. Cette instruction permet des mises à jour de toutes les variables de contrôle de boucle. Cette déclaration peut être laissée vide, tant qu'un point-virgule apparaît après une expression booléenne.
L'expression booléenne évalue à nouveau le calcul. Si c'est vrai, Loop Exécuter et répéter le processus (Loop Body, puis mettez à jour les étapes, puis Booléen Expression). Après cela, l'expression booléenne est fausse, la boucle se termine.
Exemple
classe publique test {public static void main (String args []) {for (int x = 10; x <20; x = x + 1) {System.out.print ("valeur de x:" + x); System.out.print ("/ n"); }}}Cela produira les résultats suivants:
Valeur de x: 10value de x: 11value de x: 12value de x: 13value de x: 14value de x: 15value de x: 16value de x: 17value de x: 18value de x: 19
Nouvelles fonctionnalités pour les boucles en java
Depuis Java 5, une boucle améliorée est introduite. Ceci est principalement utilisé pour les tableaux.
grammaire
La syntaxe pour la boucle améliorée est:
pour (Déclaration: expression) {// instructions}Déclaration: Nouveau déclare une variable de bloc, qui est une variable compatible avec les éléments du tableau auquel vous accédez. La variable peut être utilisée dans le bloc For et sa valeur car l'élément de tableau actuel sera le même.
Expression: Ce résultat de calcul nécessite un tableau de boucle à terminer. Une expression peut être une variable de tableau ou un appel de méthode qui renvoie un tableau.
Exemple
classe publique test {public static void main (String args []) {int [] nombres = {10, 20, 30, 40, 50}; pour (int x: nombres) {System.out.print (x); System.out.print (","); } System.out.print ("/ n"); String [] noms = {"James", "Larry", "Tom", "Lacy"}; for (String name: noms) {System.out.print (name); System.out.print (","); }}}Cela produira les résultats suivants:
10, 20, 30, 40, 50, James, Larry, Tom, Lacy,
casser les mots clés
La rupture du mot-clé est utilisée pour arrêter toute la boucle. Le mot clé Break doit être utilisé dans n'importe quelle boucle ou dans une instruction Switch.
La rupture de mot-clé arrêtera l'exécution de la boucle la plus intérieure et commencera à exécuter la ligne de code suivante après le bloc.
grammaire
Break Syntax est une instruction distincte dans n'importe quelle boucle:
Copiez le code comme suit: Break
Exemple
classe publique test {public static void main (String args []) {int [] nombres = {10, 20, 30, 40, 50}; pour (int x: nombres) {if (x == 30) {break; } System.out.print (x); System.out.print ("/ n"); }}}Cela produira les résultats suivants:
1020
Continuer les mots clés
Le mot-clé continue peut être utilisé dans la structure de contrôle de n'importe quel lien. Cela fait sauter immédiatement la boucle à la prochaine itération de la boucle.
Dans une boucle pour une boucle, le mot-clé continu fait que le flux de contrôle passe immédiatement à l'instruction de mise à jour.
Dans une boucle de boucle ou de boucle DO / while, le flux de contrôle saute immédiatement vers l'expression booléenne.
grammaire
La syntaxe continue est une instruction distincte dans n'importe quelle boucle:
Copiez le code comme suit: Continuez
Exemple
public static void main (String args []) {int [] nombres = {10, 20, 30, 40, 50}; pour (int x: nombres) {if (x == 30) {continu; } System.out.print (x); System.out.print ("/ n"); }}}Cela produira les résultats suivants:
10204050
Jugement conditionnel
Il existe deux types de déclarations de jugement conditionnel en Java, qui sont:
Si déclaration:
Une déclaration IF se compose d'une expression booléenne suivie d'une ou plusieurs déclarations.
grammaire
La syntaxe d'une instruction IF est:
if (boolean_expression) {// Les instructions exécuteront si l'expression booléenne est vraie}Si la valeur de l'expression booléenne est vraie, l'instruction Block IF dans le code sera exécutée. Si ce n'est pas vrai, le premier ensemble de code après la fin de l'instruction if (après les accolades) sera exécuté.
Exemple
classe publique test {public static void main (String args []) {int x = 10; if (x <20) {System.out.print ("This is if instruction"); }}}Cela produira les résultats suivants:
C'est si déclaration
Si ... Else Déclaration
Toute instruction IF peut être suivie d'une instruction Else facultative. Lorsque l'expression booléenne est fausse, l'instruction est exécutée.
grammaire
La syntaxe de si ... else est:
if (boolean_expression) {// exécute lorsque l'expression booléenne est vraie} else {// exécute lorsque l'expression booléenne est fausse}Exemple
classe publique test {public static void main (String args []) {int x = 30; if (x <20) {System.out.print ("This is if instruction"); } else {System.out.print ("This is else instruction"); }}}Cela produira les résultats suivants:
C'est une déclaration d'autre
Si ... sinon si ...
Si peut être suivi d'une déclaration facultative si ... else. Il est très utile de tester une seule instruction IF et une instruction Else IF dans différentes conditions.
Il y a quelques points à garder à l'esprit lors de l'utilisation des instructions si, si, sinon.
grammaire
La syntaxe de si ... else est:
if (boolean_expression 1) {// exécute lorsque l'expression booléenne 1 est vrai} else if (boolean_expression 2) {// exécute quand l'expression booléenne 2 est vrai} else if (boolean_expression 3) {// exécute lorsque l'expression booléenne 3 est vraie} else {// exécute lorsque le non de la condition ci-dessus est vrai.}.Exemple
classe publique test {public static void main (String args []) {int x = 30; if (x == 10) {System.out.print ("La valeur de x est 10"); } else if (x == 20) {System.out.print ("La valeur de x est 20"); } else if (x == 30) {System.out.print ("La valeur de x est 30"); } else {System.out.print ("This is else instruction"); }}}Cela produira les résultats suivants:
La valeur de x est de 30
Déclaration imbriquée si ... else
Il s'agit toujours d'une déclaration IF-ELSE imbriquée légale, ce qui signifie que vous pouvez utiliser une déclaration si ou bien si dans une autre énoncé si ou bien si.
grammaire
La syntaxe de imbriqué si ... else est la suivante:
if (boolean_expression 1) {// exécute lorsque l'expression booléenne 1 est vrai si (boolean_expression 2) {// exécute lorsque l'expression booléenne 2 est vrai}}Parce que nous avons imbriqué des déclarations, nous pouvons nicher autrement si ... d'autre d'une manière similaire.
Exemple
classe publique test {public static void main (String args []) {int x = 30; int y = 10; if (x == 30) {if (y == 10) {System.out.print ("x = 30 et y = 10"); }}}}Cela produira les résultats suivants:
X = 30 et y = 10
Déclaration de commutation
L'instruction Switch permet à une variable de tester une série d'égalité de valeur. Chaque valeur est appelée un cas et les variables démarrées sont vérifiées pour chaque cas.
grammaire
La syntaxe pour les boucles améliorées est:
switch (expression) {case valeur: // instructions briss; // Valeur de cas facultative: // instructions Break; // Facultatif // Vous pouvez avoir n'importe quel nombre d'instructions de cas. par défaut: // Instructions facultatives //Les règles suivantes s'appliquent aux instructions de commutation:
Exemple
Classe publique Test {public static void main (String args []) {// char grade = args [0] .Charat (0); Char Grade = 'C'; Switch (grade) {case 'a': System.out.println ("Excellent!"); casser; case 'b': case 'c': System.out.println ("bien fait"); casser; case 'd': System.out.println ("vous avez réussi"); case 'f': System.out.println ("Mieux réessayer"); casser; par défaut: System.out.println ("grade non valide"); } System.out.println ("Votre note est" + grade); }}Compilez et exécutez le programme ci-dessus qui utilise divers paramètres de ligne de commande. Cela produira les résultats suivants:
$ java testwell fait votre note est un C