Structures de contrôle en Java

1. Vue d'ensemble

Au sens le plus élémentaire, un programme est une liste d'instructions. Les structures de contrôle sont des blocs de programmation qui peuvent changer le chemin que nous empruntons à travers ces instructions.

Dans ce didacticiel, nous explorerons les structures de contrôle en Java.

Il existe trois types de structures de contrôle:

  • Branches conditionnelles, que nous utilisons pour choisir entre deux ou plusieurs chemins. Il existe trois types en Java: if / else / else if , opérateur ternaire et switch .
  • Boucles utilisées pour parcourir plusieurs valeurs / objets et exécuter à plusieurs reprises des blocs de code spécifiques. Les types de boucles de base en Java sont for , while et do while .
  • Instructions de branchement, qui sont utilisées pour modifier le flux de contrôle dans les boucles. Il existe deux types en Java: interrompre et continuer .

2. If / Else / Else If

L' instruction if / else est la plus élémentaire des structures de contrôle, mais peut également être considérée comme la base même de la prise de décision en programmation.

Alors que if peut être utilisé seul, le scénario d'utilisation le plus courant consiste à choisir entre deux chemins avec if / else :

if (count > 2) { System.out.println("Count is higher than 2"); } else { System.out.println("Count is lower or equal than 2"); }

Théoriquement, nous pouvons enchaîner ou imbriquer à l'infini des blocs if / else , mais cela nuira à la lisibilité du code, et c'est pourquoi ce n'est pas conseillé.

Nous explorerons des déclarations alternatives dans le reste de cet article.

3. Opérateur ternaire

Nous pouvons utiliser un opérateur ternaire comme expression abrégée qui fonctionne comme une instruction if / else .

Voyons à nouveau notre exemple if / else :

if (count > 2) { System.out.println("Count is higher than 2"); } else { System.out.println("Count is lower or equal than 2"); }

Nous pouvons refactoriser cela avec un ternaire comme suit:

System.out.println(count > 2 ? "Count is higher than 2" : "Count is lower or equal than 2");

Bien que ternaire puisse être un excellent moyen de rendre notre code plus lisible, ce n'est pas toujours un bon substitut à if / else.

4. Commutateur

Si nous avons le choix entre plusieurs cas, nous pouvons utiliser une instruction switch .

Voyons à nouveau un exemple simple:

int count = 3; switch (count) { case 0: System.out.println("Count is equal to 0"); break; case 1: System.out.println("Count is equal to 1"); break; default: System.out.println("Count is either negative, or higher than 1"); break; }

Trois instructions if / else ou plus peuvent être difficiles à lire. Comme l'une des solutions de contournement possibles, nous pouvons utiliser le commutateur, comme indiqué ci-dessus.

Et gardez également à l'esprit que le commutateur a des limites de portée et d'entrée dont nous devons nous souvenir avant de l'utiliser.

5. Boucles

Nous utilisons des boucles lorsque nous devons répéter le même code plusieurs fois de suite.

Voyons un exemple rapide de boucles de type for et while comparables :

for (int i = 1; i <= 50; i++) { methodToRepeat(); } int whileCounter = 1; while (whileCounter <= 50) { methodToRepeat(); whileCounter++; } 

Les deux blocs de code ci-dessus appelleront methodToRepeat 50 fois.

6. Pause

Nous devons utiliser break pour sortir tôt d'une boucle.

Voyons un exemple rapide:

List names = getNameList(); String name = "John Doe"; int index = 0; for ( ; index < names.length; index++) { if (names[index].equals(name)) { break; } }

Ici, nous recherchons un nom dans une liste de noms, et nous voulons arrêter de chercher une fois que nous l'avons trouvé.

Une boucle serait normalement terminée, mais nous avons utilisé break ici pour court-circuiter cela et sortir tôt.

7. Continuer

En termes simples, continuer signifie sauter le reste de la boucle dans laquelle nous nous trouvons:

List names = getNameList(); String name = "John Doe"; String list = ""; for (int i = 0; i < names.length; i++) { if (names[i].equals(name)) { continue; } list += names[i]; }

Ici, nous ignorons l'ajout des noms en double dans la liste.

Comme nous l'avons vu ici, break and continue peut être pratique lors de l'itération, bien qu'ils puissent souvent être réécrits avec des instructions de retour ou une autre logique.

8. Conclusion

Dans cet article rapide, nous avons appris ce que sont les structures de contrôle et comment les utiliser pour gérer le contrôle de flux dans nos programmes Java.

Tout le code présenté dans cet article est disponible à l'adresse over sur GitHub.