La Programmation Orientée Objet en Java : Les boucles
Il peut y avoir une situation lorsque nous devons exécuter un bloc de code plusieurs fois, et est souvent appelé une boucle.
Java dispose de trois mécanismes de bouclage très flexibles. Vous pouvez utiliser l'une des trois boucles suivantes:
- While
- Do ... while
- For
À partir de Java 5, la boucle améliorée a été introduite. Ceci est principalement utilisé pour les tableaux.
La boucle while
Une boucle while est une structure de contrôle qui vous permet de répéter une tâche un certain nombre de fois.
Syntaxe:
La syntaxe d'une boucle while est:
while(Boolean_expression)
{
//Statements
}
Lors de l'exécution, si le résultat Boolean_expression est vrai, les actions à l'intérieur de la boucle seront exécutées. Cela continuera aussi longtemps que le résultat de l'expression est vrai.
Ici, le point clé de la boucle while est que la boucle pourrait ne jamais exécuter. Lorsque l'expression est testée et que le résultat est faux, le corps de la boucle sera ignoré et la première déclaration après la boucle while sera exécutée.
Exemple:
public class Test {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}
}
Cela produirait le résultat suivant:
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
La boucle do ... while
Une boucle do ... while est similaire à une boucle while, sauf qu'une boucle do... while est garanti pour s'exécuter au moins une fois.
Syntaxe:
La syntaxe d'une boucle do ... while est:
do
{
//Statements
}while(Boolean_expression);
Notez que l'expression booléenne apparaît à la fin de la boucle, de sorte que les instructions dans la boucle exécutent une fois avant que le booléen soit testé.
Si l'expression booléenne est vraie, le flux de contrôle saute en arrière et les instructions dans la boucle s'exécutent à nouveau. Ce processus se répète jusqu'à ce que l'expression booléenne soit fausse.
Exemple:
public class Test {
public static void main(String args[]){
int x = 10;
do{
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}while( x < 20 );
}
}
Cela produirait le résultat suivant:
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
La boucle for
Une boucle for est une structure de contrôle de répétition qui vous permet d'écrire efficacement une boucle qui doit exécuter un certain nombre de fois.
Une boucle for est utile lorsque vous savez combien de fois une tâche doit être répétée.
Syntaxe:
La syntaxe d’une boucle for est:
for(initialization; Boolean_expression; update)
{
//Statements
}
Voici le flux de contrôle d'un boucle pour :
- L'étape d'initialisation est exécutée en premier et une seule fois. Cette étape vous permet de déclarer et d'initialiser toutes les variables de contrôle de la boucle. Vous n'êtes pas obligé de faire une déclaration ici, tant qu'un point-virgule apparaît.
- Ensuite, l'expression booléenne est évaluée. S'il est vrai, le corps de la boucle est exécuté. Si elle est fausse, le corps de la boucle n'exécute pas et le flux de contrôle saute à l'état suivant après la boucle for.
- Une fois que le corps de la boucle for s'effectue, le flux de contrôle retourne à l'état de mise à jour. Cette déclaration vous permet de mettre à jour toutes les variables de contrôle de la boucle. Cette déclaration peut être laissée vide, tant qu'un point-virgule apparaît après l'expression booléenne.
- L'expression booléenne est maintenant évaluée à nouveau. S'il est vrai, la boucle s'effectue et le processus se répète (corps de boucle, puis étape de mise à jour, puis expression booléenne). Une fois que l'expression booléenne est fausse, la boucle for se termine.
Exemple:
public class Test {
public static void main(String args[]) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("value of x : " + x );
System.out.print("\n");
}
}
}
Cela produirait le résultat suivant:
value of x : 10
value of x : 11
value of x : 12
value of x : 13
value of x : 14
value of x : 15
value of x : 16
value of x : 17
value of x : 18
value of x : 19
Amélioration de la boucle for en Java
À partir de Java 5, la boucle améliorée a été introduite. Ceci est principalement utilisé pour les tableaux.
Syntaxe:
La syntaxe de la boucle for améliorée est:
for(declaration : expression)
{
//Statements
}
- Déclaration: la variable de bloc nouvellement déclarée, qui est d'un type compatible avec les éléments du tableau auquel vous accédez. La variable sera disponible dans le bloc for et sa valeur serait la même que l'élément de tableau actuel.
- Expression: Évalue le tableau dont vous avez besoin de passer à travers. L'expression peut être une variable de tableau ou un appel de méthode qui renvoie un tableau.
Exemple:
public class Test {
public static void main(String args[]){
int[] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String[] names ={"James", "Larry", "Tom", "Lacy"};
for(String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
Cela produirait le résultat suivant:
10,20,30,40,50,
James,Larry,Tom,Lacy,
Le mot-clé break
Le mot-clé break est utilisé pour arrêter la boucle. Le mot-clé break doit être utilisé dans n'importe quelle boucle ou une déclaration de commutation.
Le mot-clé break interrompt l'exécution de la boucle la plus interne et commence à exécuter la suite de code après le bloc.
Syntaxe:
La syntaxe d'une pause est une déclaration unique dans n'importe quelle boucle:
break;
Exemple:
public class Test {
public static void main(String args[]) {
int[] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}
Cela produirait le résultat suivant:
10
20
Le mot-clé continue
Le mot-clé continue peut être utilisé dans l'une des structures de contrôle de la boucle. Cela fait que la boucle passe immédiatement à la prochaine itération de la boucle.
- Dans une boucle for, le mot-clé continue génère un flux de contrôle pour passer immédiatement à l'état de mise à jour.
- Dans une boucle while ou do…while, le flux de contrôle passe immédiatement à l'expression booléenne.
Syntaxe:
La syntaxe de continue est une déclaration unique dans n'importe quelle boucle:
continue;
Exemple:
public class Test {
public static void main(String args[]) {
int[] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}
Cela produirait le résultat suivant:
10
20
40
50